testit-js-commons 3.7.9 → 4.0.0

package/lib/strategy/base.strategy.js

@@ -11,6 +11,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseStrategy = void 0;
 const client_1 = require("../client");
+const utils_1 = require("../common/utils");
+const syncstorage_1 = require("../services/syncstorage");
 class BaseStrategy {
     constructor(config) {
         this.config = config;
@@ -19,14 +21,26 @@ class BaseStrategy {
     }
     setup() {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             const testRunId = yield this.testRunId;
+            yield this.tryStartSyncStorage(testRunId);
+            yield ((_a = this.syncStorageRunner) === null || _a === void 0 ? void 0 : _a.setWorkerStatus("in_progress"));
             yield this.client.testRuns.startTestRun(testRunId);
         });
     }
     teardown() {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             const testRunId = yield this.testRunId;
-            yield this.client.testRuns.completeTestRun(testRunId);
+            yield ((_a = this.syncStorageRunner) === null || _a === void 0 ? void 0 : _a.setWorkerStatus("completed"));
+            yield ((_b = this.syncStorageRunner) === null || _b === void 0 ? void 0 : _b.completeProcessing());
+            // With active sync-storage, run completion is finalized by sync-storage itself.
+            // Calling completeTestRun from adapters can finish the run too early and skip late results.
+            // if (this.syncStorageRunner?.isActive()) {
+            //   logTmsLoadTestRun("skip completeTestRun in adapter teardown: sync-storage is active");
+            //   return;
+            // }
+            //await this.client.testRuns.completeTestRun(testRunId);
         });
     }
     loadAutotest(autotest, status) {
@@ -67,8 +81,78 @@ class BaseStrategy {
     }
     loadTestRun(autotests) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g;
             const testRunId = yield this.testRunId;
-            return yield this.client.testRuns.loadAutotests(testRunId, autotests);
+            const firstResult = autotests[0];
+            (0, utils_1.logTmsLoadTestRun)("loadTestRun enter", {
+                testRunId,
+                batchSize: autotests.length,
+                firstExternalId: firstResult === null || firstResult === void 0 ? void 0 : firstResult.autoTestExternalId,
+                syncRunnerActive: Boolean((_b = (_a = this.syncStorageRunner) === null || _a === void 0 ? void 0 : _a.isActive) === null || _b === void 0 ? void 0 : _b.call(_a)),
+                isMaster: Boolean((_d = (_c = this.syncStorageRunner) === null || _c === void 0 ? void 0 : _c.isMasterWorker) === null || _d === void 0 ? void 0 : _d.call(_c)),
+            });
+            // InProgress is only for the first result (the one used for sync storage cut).
+            // Its final payload is deferred until teardown, so TMS does not immediately flip to final status.
+            if (firstResult) {
+                const isMasterWorker = Boolean((_f = (_e = this.syncStorageRunner) === null || _e === void 0 ? void 0 : _e.isMasterWorker) === null || _f === void 0 ? void 0 : _f.call(_e));
+                const published = yield ((_g = this.syncStorageRunner) === null || _g === void 0 ? void 0 : _g.sendInProgressTestResult((0, syncstorage_1.toTestResultCutModel)(firstResult, this.config.projectId)));
+                (0, utils_1.logTmsLoadTestRun)("syncStorage sendInProgressTestResult", {
+                    isMasterWorker,
+                    published: Boolean(published),
+                });
+                if (!isMasterWorker) {
+                    // Global ordering: non-master waits for sync-storage published flag from master.
+                    const timeoutMs = this.getInProgressFirstGraceMs();
+                    if (timeoutMs > 0 && this.syncStorageRunner) {
+                        (0, utils_1.logTmsLoadTestRun)("non-master wait for in-progress published", { timeoutMs });
+                        const publishedByMaster = yield this.syncStorageRunner.waitForInProgressPublished(timeoutMs);
+                        (0, utils_1.logTmsLoadTestRun)("non-master wait result", { publishedByMaster });
+                    }
+                    (0, utils_1.logTmsLoadTestRun)("skip InProgress stub: current worker is not sync master");
+                    yield this.client.testRuns.loadAutotests(testRunId, autotests);
+                    return;
+                }
+                if (!published) {
+                    (0, utils_1.logTmsLoadTestRun)("skip InProgress stub: sync cut was not published");
+                    yield this.client.testRuns.loadAutotests(testRunId, autotests);
+                    return;
+                }
+                (0, utils_1.logTmsLoadTestRun)("InProgress slot acquired", {
+                    autoTestExternalId: firstResult.autoTestExternalId,
+                    testRunId,
+                });
+                try {
+                    yield this.client.testRuns.postInProgressAutotestResult(testRunId, firstResult);
+                }
+                catch (err) {
+                    (0, utils_1.logTmsLoadTestRun)("postInProgressAutotestResult FAILED", {
+                        autoTestExternalId: firstResult.autoTestExternalId,
+                        message: err instanceof Error ? err.message : String(err),
+                    });
+                    throw err;
+                }
+                // For published sync-storage InProgress, finalization of the first result is handled by sync-storage.
+                const rest = autotests.slice(1);
+                if (rest.length > 0) {
+                    yield this.client.testRuns.loadAutotests(testRunId, rest);
+                }
+                return;
+            }
+            // Normal path: no placeholder created here — upload finals as-is.
+            yield this.client.testRuns.loadAutotests(testRunId, autotests);
+        });
+    }
+    tryStartSyncStorage(testRunId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.config.syncStorageEnabled) {
+                return;
+            }
+            const runner = new syncstorage_1.SyncStorageRunner(testRunId, this.config);
+            const started = yield runner.start();
+            if (!started) {
+                return;
+            }
+            this.syncStorageRunner = runner;
         });
     }
     updateTestRun(config) {
@@ -85,5 +169,16 @@ class BaseStrategy {
             this.client.testRuns.updateTestRun(testRun);
         });
     }
+    getInProgressFirstGraceMs() {
+        const raw = process.env.TMS_SYNC_INPROGRESS_FIRST_GRACE_MS;
+        if (!raw) {
+            return BaseStrategy.INPROGRESS_FIRST_GRACE_MS;
+        }
+        const parsed = Number(raw);
+        return Number.isFinite(parsed) && parsed >= 0
+            ? parsed
+            : BaseStrategy.INPROGRESS_FIRST_GRACE_MS;
+    }
 }
 exports.BaseStrategy = BaseStrategy;
+BaseStrategy.INPROGRESS_FIRST_GRACE_MS = 3000;