testit-adapter-jest 4.0.5 → 4.1.0

package/README.md

@@ -12,6 +12,10 @@ npm install testit-adapter-jest
 
 ### 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 +28,7 @@ npm install testit-adapter-jest
 | 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 |
 
 #### File
 

package/dist/globalSetup.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const testit_js_commons_1 = require("testit-js-commons");
+const testit_js_commons_2 = require("testit-js-commons");
 const globalUnhandledRejectionLogger = (reason) => {
     const normalized = reason?.body ?? reason?.error ?? reason;
-    console.error("[jest-globalSetup] unhandledRejection:", normalized);
+    testit_js_commons_2.logger.error("[jest-globalSetup] unhandledRejection:", normalized);
 };
 exports.default = async (globalConfig, projectConfig) => {
     process.on("unhandledRejection", globalUnhandledRejectionLogger);
@@ -17,6 +18,6 @@ exports.default = async (globalConfig, projectConfig) => {
         projectConfig.testEnvironmentOptions["adapterMode"] = 1;
     }
     catch (err) {
-        console.error("Failed globalSetup for testit-adapter-jest:", err?.body ?? err?.error ?? err);
+        testit_js_commons_2.logger.error("Failed globalSetup for testit-adapter-jest:", err?.body ?? err?.error ?? err);
     }
 };

package/dist/globalTeardown.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const testit_js_commons_1 = require("testit-js-commons");
 exports.default = async (globalConfig, projectConfig) => {
     try {
         if (globalThis.strategy) {
@@ -7,6 +8,6 @@ exports.default = async (globalConfig, projectConfig) => {
         }
     }
     catch (err) {
-        console.error('Failed to complete test run');
+        testit_js_commons_1.logger.error('Failed to complete test run');
     }
 };

package/dist/testitEnvironment.d.ts

@@ -18,6 +18,10 @@ export default class TestItEnvironment extends NodeEnvironment {
     private readonly usesGlobalStrategy;
     private readonly unhandledRejectionHandler;
     private finalized;
+    private readonly importRealtime;
+    private currentTestAttachmentsQueue;
+    /** Sent in realtime on test_done; finalized with afterAll on run_finish. */
+    private realtimeSent;
     constructor(jestConfig: JestEnvironmentConfig, jestContext: EnvironmentContext);
     setup(): Promise<void>;
     teardown(): Promise<void>;
@@ -40,6 +44,12 @@ export default class TestItEnvironment extends NodeEnvironment {
     saveResult(test: Extract<Event, {
         name: "test_done";
     }>["test"]): Promise<void>;
+    private snapshotAutotestData;
+    private buildSetupSteps;
+    private buildTeardownSteps;
+    private sendRealtimePayload;
+    /** afterAll hooks run after all tests; patch teardown when importRealtime is enabled. */
+    private flushRealtimeTeardown;
     loadResults(): Promise<void>;
     resetTest(): void;
     resetStep(): void;

package/dist/testitEnvironment.js

@@ -7,6 +7,7 @@ const jest_environment_node_1 = __importDefault(require("jest-environment-node")
 const testit_js_commons_1 = require("testit-js-commons");
 const debug_1 = require("debug");
 const utils_1 = require("./utils");
+const testit_js_commons_2 = require("testit-js-commons");
 const log = (0, debug_1.debug)("tms").extend("environment");
 const emptyAutotestData = () => ({
     externalId: "",
@@ -35,12 +36,16 @@ class TestItEnvironment extends jest_environment_node_1.default {
         this.autotests = [];
         this.attachmentsQueue = [];
         this.finalized = false;
+        this.currentTestAttachmentsQueue = [];
+        /** Sent in realtime on test_done; finalized with afterAll on run_finish. */
+        this.realtimeSent = [];
         const config = new testit_js_commons_1.ConfigComposer().compose(jestConfig.projectConfig.testEnvironmentOptions);
+        this.importRealtime = Boolean(config.importRealtime);
         this.additions = new testit_js_commons_1.Additions(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));
+            testit_js_commons_2.logger.error("Unhandled promise rejection in Jest environment:", this.formatError(reason));
         };
         this.testPath = (0, utils_1.excludePath)(jestContext.testPath, jestConfig.globalConfig.rootDir);
     }
@@ -50,9 +55,10 @@ class TestItEnvironment extends jest_environment_node_1.default {
         await super.setup();
         const testRunId = await this.strategy.testRunId;
         const syncRunner = this.strategy.syncStorageRunner;
-        console.debug("[jest-env] setup start", {
+        testit_js_commons_2.logger.debug("[jest-env] setup start", {
             pid: process.pid,
             testRunId,
+            importRealtime: this.importRealtime,
             usesGlobalStrategy: this.usesGlobalStrategy,
             syncRunnerActive: Boolean(syncRunner?.isActive?.()),
             syncRunnerMaster: Boolean(syncRunner?.isMasterWorker?.()),
@@ -63,7 +69,7 @@ class TestItEnvironment extends jest_environment_node_1.default {
             try {
                 await this.strategy.setup();
                 const localSyncRunner = this.strategy.syncStorageRunner;
-                console.debug("[jest-env] local setup done", {
+                testit_js_commons_2.logger.debug("[jest-env] local setup done", {
                     pid: process.pid,
                     testRunId,
                     syncRunnerActive: Boolean(localSyncRunner?.isActive?.()),
@@ -71,12 +77,12 @@ class TestItEnvironment extends jest_environment_node_1.default {
                 });
             }
             catch (err) {
-                console.error("Failed local strategy.setup() in Jest environment:", this.formatError(err));
+                testit_js_commons_2.logger.error("Failed local strategy.setup() in Jest environment:", this.formatError(err));
             }
         }
         else {
             const sharedSyncRunner = this.strategy.syncStorageRunner;
-            console.debug("[jest-env] shared strategy mode", {
+            testit_js_commons_2.logger.debug("[jest-env] shared strategy mode", {
                 pid: process.pid,
                 testRunId,
                 syncRunnerActive: Boolean(sharedSyncRunner?.isActive?.()),
@@ -141,11 +147,17 @@ class TestItEnvironment extends jest_environment_node_1.default {
                     break;
                 }
                 case "run_finish": {
+                    testit_js_commons_2.logger.debug("[jest-env] run_finish", {
+                        importRealtime: this.importRealtime,
+                        realtimeSent: this.realtimeSent.length,
+                        afterAllSteps: this.afterAllSteps.length,
+                    });
                     try {
+                        await this.flushRealtimeTeardown();
                         await this.loadResults();
                     }
                     catch (err) {
-                        console.error("Failed to load results in Jest run_finish:", this.formatError(err));
+                        testit_js_commons_2.logger.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.
@@ -155,7 +167,7 @@ class TestItEnvironment extends jest_environment_node_1.default {
                                 await this.strategy.teardown();
                             }
                             catch (err) {
-                                console.error("Failed strategy.teardown() in Jest run_finish:", this.formatError(err));
+                                testit_js_commons_2.logger.error("Failed strategy.teardown() in Jest run_finish:", this.formatError(err));
                             }
                         }
                     }
@@ -164,7 +176,7 @@ class TestItEnvironment extends jest_environment_node_1.default {
             }
         }
         catch (err) {
-            console.error("Unhandled async error in Jest environment event handler:", this.formatError(err));
+            testit_js_commons_2.logger.error("Unhandled async error in Jest environment event handler:", this.formatError(err));
         }
     }
     formatError(err) {
@@ -219,11 +231,12 @@ class TestItEnvironment extends jest_environment_node_1.default {
     }
     async saveResult(test) {
         log("Saving result for %s", test.name);
-        await Promise.allSettled(this.attachmentsQueue);
+        await Promise.allSettled(this.currentTestAttachmentsQueue);
+        const autotestSnapshot = this.snapshotAutotestData();
         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 = {
-            autoTestExternalId: this.autotestData.externalId,
+            autoTestExternalId: autotestSnapshot.externalId,
             outcome: test.errors.length > 0 ? "Failed" : "Passed",
             startedOn: test.startedAt ? new Date(test.startedAt) : undefined,
             duration: test.duration ?? undefined,
@@ -232,11 +245,120 @@ class TestItEnvironment extends jest_environment_node_1.default {
             message: this.additions.messages.join("\n").concat(errorMessage ?? ""),
             links: this.additions.links,
         };
-        this.autotests.push(this.autotestData);
-        this.autotestResults.push(result);
+        if (this.importRealtime) {
+            this.realtimeSent.push({ autotest: autotestSnapshot, result });
+            testit_js_commons_2.logger.debug("[jest-env] realtime test_done", {
+                externalId: autotestSnapshot.externalId,
+                outcome: result.outcome,
+                afterEachSteps: autotestSnapshot.afterEach.length,
+                afterAllStepsKnown: this.afterAllSteps.length,
+            });
+            try {
+                await this.sendRealtimePayload(autotestSnapshot, result, false);
+            }
+            catch (err) {
+                testit_js_commons_2.logger.error("Failed realtime send in Jest environment:", this.formatError(err));
+            }
+        }
+        else {
+            this.autotests.push(autotestSnapshot);
+            this.autotestResults.push(result);
+        }
+        this.currentTestAttachmentsQueue = [];
         this.resetTest();
     }
+    snapshotAutotestData() {
+        return {
+            ...this.autotestData,
+            beforeEach: [...this.autotestData.beforeEach],
+            afterEach: [...this.autotestData.afterEach],
+            testSteps: [...this.autotestData.testSteps],
+            attachments: [...this.autotestData.attachments],
+            links: this.autotestData.links ? [...this.autotestData.links] : [],
+            labels: this.autotestData.labels ? [...this.autotestData.labels] : [],
+            tags: this.autotestData.tags ? [...this.autotestData.tags] : [],
+        };
+    }
+    buildSetupSteps(autotest) {
+        return this.beforeAllSteps.concat(autotest.beforeEach);
+    }
+    buildTeardownSteps(autotest, includeAfterAll) {
+        const afterEach = autotest.afterEach;
+        return includeAfterAll ? afterEach.concat(this.afterAllSteps) : afterEach;
+    }
+    async sendRealtimePayload(autotest, result, includeAfterAll) {
+        const setupSteps = this.buildSetupSteps(autotest);
+        const teardownSteps = this.buildTeardownSteps(autotest, includeAfterAll);
+        testit_js_commons_2.logger.debug("[jest-env] sendRealtimePayload", {
+            externalId: autotest.externalId,
+            outcome: result.outcome,
+            includeAfterAll,
+            setupSteps: setupSteps.length,
+            teardownSteps: teardownSteps.length,
+            testSteps: autotest.testSteps.length,
+        });
+        const autotestPost = {
+            externalId: autotest.externalId,
+            title: autotest.title,
+            name: autotest.name,
+            description: autotest.description,
+            links: autotest.links,
+            labels: autotest.labels,
+            tags: autotest.tags,
+            namespace: autotest.namespace ?? testit_js_commons_1.Utils.getDir(this.testPath),
+            classname: autotest.classname ?? testit_js_commons_1.Utils.getFileName(this.testPath),
+            setup: setupSteps,
+            steps: autotest.testSteps,
+            teardown: teardownSteps,
+            externalKey: autotest.externalKey,
+        };
+        await this.strategy.loadAutotest(autotestPost, result.outcome);
+        await this.strategy.loadTestRun([
+            {
+                autoTestExternalId: autotestPost.externalId,
+                outcome: result.outcome,
+                startedOn: result.startedOn,
+                duration: result.duration,
+                attachments: result.attachments,
+                message: result.message,
+                links: result.links,
+                stepResults: autotest.testSteps,
+                traces: result.traces,
+                setupResults: setupSteps,
+                teardownResults: teardownSteps,
+                parameters: autotest.parameters !== undefined ? (0, utils_1.mapParams)(autotest.parameters) : undefined,
+            },
+        ]);
+    }
+    /** afterAll hooks run after all tests; patch teardown when importRealtime is enabled. */
+    async flushRealtimeTeardown() {
+        if (!this.importRealtime || this.realtimeSent.length === 0 || this.afterAllSteps.length === 0) {
+            testit_js_commons_2.logger.debug("[jest-env] flushRealtimeTeardown skip", {
+                importRealtime: this.importRealtime,
+                realtimeSent: this.realtimeSent.length,
+                afterAllSteps: this.afterAllSteps.length,
+            });
+            return;
+        }
+        testit_js_commons_2.logger.debug("[jest-env] flushRealtimeTeardown", {
+            tests: this.realtimeSent.length,
+            afterAllSteps: this.afterAllSteps.length,
+        });
+        for (const { autotest, result } of this.realtimeSent) {
+            try {
+                await this.sendRealtimePayload(autotest, result, true);
+            }
+            catch (err) {
+                testit_js_commons_2.logger.error("Failed realtime teardown flush in Jest environment:", this.formatError(err));
+            }
+        }
+    }
     async loadResults() {
+        if (this.importRealtime) {
+            testit_js_commons_2.logger.debug("[jest-env] loadResults skip (importRealtime)");
+            return;
+        }
+        testit_js_commons_2.logger.debug("[jest-env] loadResults batch", { tests: this.autotests.length });
         log("Waiting for attachments to be uploaded");
         await Promise.allSettled(this.attachmentsQueue);
         const results = [];
@@ -265,7 +387,7 @@ class TestItEnvironment extends jest_environment_node_1.default {
                 await this.strategy.loadAutotest(autotestPost, result.outcome);
             }
             catch (err) {
-                console.error("Failed to load autotest in Jest environment:", this.formatError(err));
+                testit_js_commons_2.logger.error("Failed to load autotest in Jest environment:", this.formatError(err));
             }
             results.push({
                 autoTestExternalId: autotestPost.externalId,
@@ -287,7 +409,7 @@ class TestItEnvironment extends jest_environment_node_1.default {
             await this.strategy.loadTestRun(results);
         }
         catch (err) {
-            console.error("Failed to load test run in Jest environment:", this.formatError(err));
+            testit_js_commons_2.logger.error("Failed to load test run in Jest environment:", this.formatError(err));
         }
     }
     resetTest() {
@@ -337,10 +459,11 @@ class TestItEnvironment extends jest_environment_node_1.default {
             return ids;
         })
             .catch((err) => {
-            console.log("Error uploading attachment (Jest). \n", err?.body ?? err?.error ?? err);
+            testit_js_commons_2.logger.log("Error uploading attachment (Jest). \n", err?.body ?? err?.error ?? err);
             return [];
         });
         this.attachmentsQueue.push(promise);
+        this.currentTestAttachmentsQueue.push(promise);
         return promise;
     }
     setLinks(links) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testit-adapter-jest",
-  "version": "4.0.5",
+  "version": "4.1.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": "4.0.5"
+    "testit-js-commons": "4.1.0"
   },
   "devDependencies": {
     "@types/debug": "^4.1.7",