testit-js-commons 3.7.9 → 4.0.0

package/lib/services/syncstorage/syncstorage.runner.js

@@ -0,0 +1,350 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncStorageRunner = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const https_1 = require("https");
+const path_1 = require("path");
+const process_1 = require("process");
+const child_process_1 = require("child_process");
+// Generated sync-storage client is bundled into lib/sync-storage/dist during build.
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const SyncStorageClient = require("../../sync-storage/dist/index");
+class SyncStorageRunner {
+    constructor(testRunId, config) {
+        var _a;
+        this.testRunId = testRunId;
+        this.config = config;
+        this.isMaster = false;
+        this.alreadyInProgress = false;
+        this.inProgressPublishing = false;
+        this.running = false;
+        this.workerPid = `worker-${process.pid}-${Date.now()}`;
+        this.baseUrl = config.url;
+        this.port = (_a = config.syncStoragePort) !== null && _a !== void 0 ? _a : "49152";
+        this.serviceUrl = `http://localhost:${this.port}`;
+        const apiClient = new SyncStorageClient.ApiClient(this.serviceUrl);
+        apiClient.timeout = SyncStorageRunner.REQUEST_TIMEOUT_MS;
+        this.healthApi = new SyncStorageClient.HealthApi(apiClient);
+        this.workersApi = new SyncStorageClient.WorkersApi(apiClient);
+        this.testResultsApi = new SyncStorageClient.TestResultsApi(apiClient);
+        this.completionApi = new SyncStorageClient.CompletionApi(apiClient);
+        this.registerRequestModel = SyncStorageClient.RegisterRequest;
+        this.setWorkerStatusRequestModel = SyncStorageClient.SetWorkerStatusRequest;
+        this.testResultCutModel = SyncStorageClient.TestResultCutApiModel;
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const healthy = yield this.healthcheck();
+                if (!healthy) {
+                    const started = yield this.startLocalProcess();
+                    if (!started) {
+                        return false;
+                    }
+                }
+                const request = this.registerRequestModel.constructFromObject({
+                    pid: this.workerPid,
+                    testRunId: this.testRunId,
+                    baseUrl: this.baseUrl,
+                    privateToken: this.config.privateToken,
+                });
+                const response = yield this.withRetry(() => __awaiter(this, void 0, void 0, function* () { return this.workersApi.registerPost(request); }), SyncStorageRunner.RETRY_COUNT);
+                this.isMaster = Boolean(response === null || response === void 0 ? void 0 : response.is_master);
+                this.running = true;
+                return true;
+            }
+            catch (error) {
+                console.warn(`Sync storage start failed: ${error}`);
+                return false;
+            }
+        });
+    }
+    isActive() {
+        return this.running;
+    }
+    isMasterWorker() {
+        return this.isMaster;
+    }
+    isAlreadyInProgress() {
+        return this.alreadyInProgress;
+    }
+    waitForInProgressPublished(timeoutMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.running) {
+                return false;
+            }
+            if (this.alreadyInProgress) {
+                return true;
+            }
+            const deadline = Date.now() + Math.max(0, timeoutMs);
+            while (Date.now() < deadline) {
+                try {
+                    const state = yield this.testResultsApi.inProgressPublishedGet(this.testRunId);
+                    if (Boolean(state === null || state === void 0 ? void 0 : state.published)) {
+                        this.alreadyInProgress = true;
+                        return true;
+                    }
+                }
+                catch (_a) {
+                    // Endpoint can be temporarily unavailable; continue best-effort polling.
+                }
+                yield this.delay(SyncStorageRunner.IN_PROGRESS_POLL_MS);
+            }
+            return false;
+        });
+    }
+    sendInProgressTestResult(model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.running || !this.isMaster || this.alreadyInProgress || this.inProgressPublishing) {
+                console.log("[syncstorage] skip in-progress cut publish", {
+                    reason: {
+                        notRunning: !this.running,
+                        notMaster: !this.isMaster,
+                        alreadyInProgress: this.alreadyInProgress,
+                        publishingInFlight: this.inProgressPublishing,
+                    },
+                    workerPid: this.workerPid,
+                });
+                return false;
+            }
+            if (!model.projectId || !model.autoTestExternalId || !model.statusCode || !model.statusType) {
+                console.warn("Sync storage in-progress payload is incomplete; skipping publish.");
+                console.log("[syncstorage] incomplete in-progress cut payload", {
+                    hasProjectId: Boolean(model.projectId),
+                    hasAutoTestExternalId: Boolean(model.autoTestExternalId),
+                    hasStatusCode: Boolean(model.statusCode),
+                    hasStatusType: Boolean(model.statusType),
+                });
+                return false;
+            }
+            this.inProgressPublishing = true;
+            try {
+                const request = this.testResultCutModel.constructFromObject({
+                    projectId: model.projectId,
+                    autoTestExternalId: model.autoTestExternalId,
+                    statusCode: model.statusCode,
+                    statusType: model.statusType,
+                    startedOn: model.startedOn,
+                });
+                yield this.withRetry(() => __awaiter(this, void 0, void 0, function* () { return this.testResultsApi.inProgressTestResultPost(this.testRunId, request); }), SyncStorageRunner.RETRY_COUNT);
+                this.alreadyInProgress = true;
+                console.log("[syncstorage] alreadyInProgress set", {
+                    workerPid: this.workerPid,
+                    autoTestExternalId: model.autoTestExternalId,
+                });
+                console.log("[syncstorage] in-progress cut published", {
+                    workerPid: this.workerPid,
+                    autoTestExternalId: model.autoTestExternalId,
+                });
+                return true;
+            }
+            catch (error) {
+                console.warn(`Sync storage in-progress publish failed: ${error}`);
+                console.log("[syncstorage] in-progress cut publish failed", {
+                    workerPid: this.workerPid,
+                    autoTestExternalId: model.autoTestExternalId,
+                });
+                return false;
+            }
+            finally {
+                this.inProgressPublishing = false;
+            }
+        });
+    }
+    setWorkerStatus(status) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.running) {
+                return;
+            }
+            try {
+                const request = this.setWorkerStatusRequestModel.constructFromObject({
+                    pid: this.workerPid,
+                    status,
+                    testRunId: this.testRunId,
+                });
+                yield this.withRetry(() => __awaiter(this, void 0, void 0, function* () { return this.workersApi.setWorkerStatusPost(request); }), SyncStorageRunner.RETRY_COUNT);
+            }
+            catch (error) {
+                console.warn(`Sync storage set worker status failed: ${error}`);
+            }
+        });
+    }
+    completeProcessing() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.running || !this.isMaster) {
+                return;
+            }
+            try {
+                yield this.withRetry(() => __awaiter(this, void 0, void 0, function* () { return this.completionApi.waitCompletionGet(this.testRunId); }), SyncStorageRunner.RETRY_COUNT);
+                return;
+            }
+            catch (_a) {
+                // Fallback to force completion when wait endpoint is unavailable or times out.
+            }
+            try {
+                yield this.withRetry(() => __awaiter(this, void 0, void 0, function* () { return this.completionApi.forceCompletionGet(this.testRunId); }), SyncStorageRunner.RETRY_COUNT);
+            }
+            catch (error) {
+                console.warn(`Sync storage completion failed: ${error}`);
+            }
+        });
+    }
+    healthcheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.withRetry(() => __awaiter(this, void 0, void 0, function* () { return this.healthApi.healthGet(); }), 1);
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+    }
+    startLocalProcess() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const executablePath = yield this.prepareExecutable();
+                const command = [
+                    "--testRunId", this.testRunId,
+                    "--port", this.port,
+                    "--baseURL", this.baseUrl,
+                    "--privateToken", this.config.privateToken,
+                ];
+                this.syncStorageProcess = (0, child_process_1.spawn)(executablePath, command, {
+                    cwd: (0, path_1.join)(process.cwd(), "build", ".caches"),
+                    stdio: "ignore",
+                    detached: process_1.platform === "win32",
+                });
+                const started = yield this.waitForStartup();
+                if (started) {
+                    yield this.delay(SyncStorageRunner.PROCESS_WARMUP_MS);
+                }
+                return started;
+            }
+            catch (error) {
+                console.warn(`Sync storage local process start failed: ${error}`);
+                return false;
+            }
+        });
+    }
+    waitForStartup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deadline = Date.now() + SyncStorageRunner.STARTUP_TIMEOUT_MS;
+            while (Date.now() < deadline) {
+                if (yield this.healthcheck()) {
+                    return true;
+                }
+                yield this.delay(SyncStorageRunner.STARTUP_POLL_MS);
+            }
+            return false;
+        });
+    }
+    prepareExecutable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cachesDir = (0, path_1.join)(process.cwd(), "build", ".caches");
+            if (!(0, fs_1.existsSync)(cachesDir)) {
+                (0, fs_1.mkdirSync)(cachesDir, { recursive: true });
+            }
+            const fileName = this.getBinaryName();
+            const targetPath = (0, path_1.join)(cachesDir, fileName);
+            if (!(0, fs_1.existsSync)(targetPath)) {
+                const url = `${SyncStorageRunner.REPO_BASE}/${SyncStorageRunner.VERSION}/${fileName}`;
+                yield this.downloadFile(url, targetPath);
+            }
+            if (process_1.platform !== "win32") {
+                yield (0, promises_1.chmod)(targetPath, 0o755);
+            }
+            return targetPath;
+        });
+    }
+    getBinaryName() {
+        const osPart = this.getOsPart();
+        const archPart = this.getArchPart();
+        const ext = osPart === "windows" ? ".exe" : "";
+        return `syncstorage-${SyncStorageRunner.VERSION}-${osPart}_${archPart}${ext}`;
+    }
+    getOsPart() {
+        if (process_1.platform === "win32")
+            return "windows";
+        if (process_1.platform === "darwin")
+            return "darwin";
+        if (process_1.platform === "linux")
+            return "linux";
+        throw new Error(`Unsupported OS: ${process_1.platform}`);
+    }
+    getArchPart() {
+        if (process_1.arch === "x64")
+            return "amd64";
+        if (process_1.arch === "arm64")
+            return "arm64";
+        throw new Error(`Unsupported arch: ${process_1.arch}`);
+    }
+    downloadFile(url, targetPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve, reject) => {
+                const file = (0, fs_1.createWriteStream)(targetPath);
+                const request = (0, https_1.get)(url, { headers: { "User-Agent": "testit-js-commons" } }, (response) => {
+                    if (response.statusCode &&
+                        response.statusCode >= 300 &&
+                        response.statusCode < 400 &&
+                        response.headers.location) {
+                        file.close();
+                        this.downloadFile(response.headers.location, targetPath).then(resolve).catch(reject);
+                        return;
+                    }
+                    if (!response.statusCode || response.statusCode >= 400) {
+                        file.close();
+                        reject(new Error(`Download failed: HTTP ${response.statusCode}`));
+                        return;
+                    }
+                    response.pipe(file);
+                    file.on("finish", () => {
+                        file.close();
+                        resolve();
+                    });
+                });
+                request.on("error", (err) => reject(err));
+                file.on("error", (err) => reject(err));
+            });
+        });
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    withRetry(fn, retries) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let lastError;
+            for (let i = 0; i < retries; i++) {
+                try {
+                    return yield fn();
+                }
+                catch (error) {
+                    lastError = error;
+                    if (i < retries - 1) {
+                        yield this.delay(300);
+                    }
+                }
+            }
+            throw lastError;
+        });
+    }
+}
+exports.SyncStorageRunner = SyncStorageRunner;
+SyncStorageRunner.VERSION = "v0.2.12";
+SyncStorageRunner.STARTUP_TIMEOUT_MS = 30000;
+SyncStorageRunner.STARTUP_POLL_MS = 1000;
+SyncStorageRunner.PROCESS_WARMUP_MS = 2000;
+SyncStorageRunner.REQUEST_TIMEOUT_MS = 15000;
+SyncStorageRunner.RETRY_COUNT = 3;
+SyncStorageRunner.IN_PROGRESS_POLL_MS = 200;
+SyncStorageRunner.REPO_BASE = "https://github.com/testit-tms/sync-storage-public/releases/download";

package/lib/services/syncstorage/syncstorage.runner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/services/syncstorage/syncstorage.runner.test.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const syncstorage_runner_1 = require("./syncstorage.runner");
+function makeConfig() {
+    return {
+        url: "http://localhost:8080",
+        privateToken: "token",
+        projectId: "11111111-1111-1111-1111-111111111111",
+        configurationId: "22222222-2222-2222-2222-222222222222",
+        testRunId: "33333333-3333-3333-3333-333333333333",
+        syncStorageEnabled: true,
+        syncStoragePort: "49152",
+    };
+}
+describe("SyncStorageRunner", () => {
+    it("should mark runner as active and resolve master status after start", () => __awaiter(void 0, void 0, void 0, function* () {
+        const runner = new syncstorage_runner_1.SyncStorageRunner("run-1", makeConfig());
+        const internal = runner;
+        internal.healthcheck = jest.fn().mockResolvedValue(true);
+        internal.workersApi = { registerPost: jest.fn().mockResolvedValue({ is_master: true }) };
+        const started = yield runner.start();
+        expect(started).toBe(true);
+        expect(runner.isActive()).toBe(true);
+        expect(runner.isMasterWorker()).toBe(true);
+    }));
+    it("should send in-progress result only once", () => __awaiter(void 0, void 0, void 0, function* () {
+        const runner = new syncstorage_runner_1.SyncStorageRunner("run-1", makeConfig());
+        const internal = runner;
+        internal.healthcheck = jest.fn().mockResolvedValue(true);
+        internal.workersApi = { registerPost: jest.fn().mockResolvedValue({ is_master: true }) };
+        internal.testResultsApi = { inProgressTestResultPost: jest.fn().mockResolvedValue({ status: "ok" }) };
+        internal.testResultCutModel = { constructFromObject: (obj) => obj };
+        yield runner.start();
+        const first = yield runner.sendInProgressTestResult({
+            projectId: "11111111-1111-1111-1111-111111111111",
+            autoTestExternalId: "A",
+            statusCode: "Passed",
+            statusType: "Succeeded",
+            startedOn: new Date(),
+        });
+        const second = yield runner.sendInProgressTestResult({
+            projectId: "11111111-1111-1111-1111-111111111111",
+            autoTestExternalId: "B",
+            statusCode: "Passed",
+            statusType: "Succeeded",
+            startedOn: new Date(),
+        });
+        expect(first).toBe(true);
+        expect(second).toBe(false);
+    }));
+    it("should skip publish when payload is incomplete", () => __awaiter(void 0, void 0, void 0, function* () {
+        const runner = new syncstorage_runner_1.SyncStorageRunner("run-1", makeConfig());
+        const internal = runner;
+        internal.healthcheck = jest.fn().mockResolvedValue(true);
+        internal.workersApi = { registerPost: jest.fn().mockResolvedValue({ is_master: true }) };
+        internal.testResultsApi = { inProgressTestResultPost: jest.fn().mockResolvedValue({ status: "ok" }) };
+        internal.testResultCutModel = { constructFromObject: (obj) => obj };
+        yield runner.start();
+        const ok = yield runner.sendInProgressTestResult({
+            projectId: "",
+            autoTestExternalId: "A",
+            statusCode: "Passed",
+            statusType: "Succeeded",
+            startedOn: new Date(),
+        });
+        expect(ok).toBe(false);
+        expect(internal.testResultsApi.inProgressTestResultPost).not.toHaveBeenCalled();
+    }));
+});

package/lib/services/syncstorage/syncstorage.type.d.ts

@@ -0,0 +1,21 @@
+import { Outcome } from "../../common";
+import { AutotestResult } from "../testruns";
+export type WorkerStatus = "in_progress" | "completed";
+export interface TestResultCutModel {
+    projectId: string;
+    autoTestExternalId: string;
+    statusCode: Outcome;
+    statusType: string;
+    startedOn?: Date;
+}
+export interface ISyncStorageRunner {
+    start(): Promise<boolean>;
+    isActive(): boolean;
+    isMasterWorker(): boolean;
+    isAlreadyInProgress(): boolean;
+    waitForInProgressPublished(timeoutMs: number): Promise<boolean>;
+    sendInProgressTestResult(model: TestResultCutModel): Promise<boolean>;
+    setWorkerStatus(status: WorkerStatus): Promise<void>;
+    completeProcessing(): Promise<void>;
+}
+export declare function toTestResultCutModel(result: AutotestResult, projectId: string): TestResultCutModel;

package/lib/services/syncstorage/syncstorage.type.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTestResultCutModel = toTestResultCutModel;
+/** Same mapping as TestRunConverter.mapToStatusType — TMS expects both fields on the cut model. */
+const OUTCOME_TO_STATUS_TYPE = {
+    Passed: "Succeeded",
+    Failed: "Failed",
+    Blocked: "Incomplete",
+    Skipped: "Incomplete",
+};
+function toTestResultCutModel(result, projectId) {
+    return {
+        projectId,
+        autoTestExternalId: result.autoTestExternalId,
+        statusCode: result.outcome,
+        statusType: OUTCOME_TO_STATUS_TYPE[result.outcome],
+        startedOn: result.startedOn,
+    };
+}

package/lib/services/testruns/testruns.converter.d.ts

@@ -6,6 +6,7 @@ export interface ITestRunConverter {
     toLocalState(state: TestRunState): RunState;
     toLocalTestRun(testRun: TestRunV2ApiResult): TestRunGet;
     toOriginAutotestResult(autotest: AutotestResult): AutoTestResultsForTestRunModel;
+    toOriginAutotestResultInProgress(autotest: AutotestResult): AutoTestResultsForTestRunModel;
 }
 export declare class TestRunConverter extends BaseConverter implements ITestRunConverter {
     private autotestConverter;
@@ -13,6 +14,7 @@ export declare class TestRunConverter extends BaseConverter implements ITestRunC
     toLocalState(state: TestRunState): RunState;
     toOriginState(state: RunState): TestRunState;
     mapToStatusType(status: Outcome): string;
+    toOriginAutotestResultInProgress(autotest: AutotestResult): AutoTestResultsForTestRunModel;
     toOriginAutotestResult(autotest: AutotestResult): AutoTestResultsForTestRunModel;
     toLocalTestRun(testRun: TestRunV2ApiResult): TestRunGet;
 }

package/lib/services/testruns/testruns.converter.js

@@ -26,6 +26,9 @@ class TestRunConverter extends common_1.BaseConverter {
         };
         return statusMap[status];
     }
+    toOriginAutotestResultInProgress(autotest) {
+        return Object.assign(Object.assign({}, this.toOriginAutotestResult(autotest)), { statusType: "InProgress" });
+    }
     toOriginAutotestResult(autotest) {
         var _a, _b, _c, _d;
         const model = {

package/lib/services/testruns/testruns.service.d.ts

@@ -12,5 +12,7 @@ export declare class TestRunsService extends BaseService implements ITestRunsSer
     updateTestRun(testRun: TestRunGet): Promise<void>;
     startTestRun(testRunId: TestRunId): Promise<void>;
     completeTestRun(testRunId: TestRunId): Promise<void>;
+    postInProgressAutotestResult(testRunId: string, result: AutotestResult): Promise<void>;
     loadAutotests(testRunId: string, results: Array<AutotestResult>): Promise<void>;
+    private sendAutotestResultWithRetry;
 }

package/lib/services/testruns/testruns.service.js

@@ -138,12 +138,73 @@ class TestRunsService extends common_1.BaseService {
             }
         });
     }
+    postInProgressAutotestResult(testRunId, result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const model = this._converter.toOriginAutotestResultInProgress(result);
+            (0, utils_1.escapeHtmlInObjectArray)([model]);
+            (0, utils_1.logTmsLoadTestRun)("POST setAutoTestResults (InProgress stub)", {
+                testRunId,
+                autoTestExternalId: model.autoTestExternalId,
+                statusType: model.statusType,
+                statusCode: model.statusCode,
+                hasStartedOn: Boolean(model.startedOn),
+            });
+            yield this._client.setAutoTestResultsForTestRun(testRunId, { autoTestResultsForTestRunModel: [model] });
+            (0, utils_1.logTmsLoadTestRun)("POST setAutoTestResults (InProgress stub) done", {
+                autoTestExternalId: model.autoTestExternalId,
+            });
+        });
+    }
     loadAutotests(testRunId, results) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             const autotestResultsForTestRun = results.map((result) => this._converter.toOriginAutotestResult(result));
             (0, utils_1.escapeHtmlInObjectArray)(autotestResultsForTestRun);
             for (const autotestResult of autotestResultsForTestRun) {
-                yield this._client.setAutoTestResultsForTestRun(testRunId, { autoTestResultsForTestRunModel: [autotestResult] });
+                (0, utils_1.logTmsLoadTestRun)("POST setAutoTestResults (final)", {
+                    testRunId,
+                    autoTestExternalId: autotestResult.autoTestExternalId,
+                    statusType: autotestResult.statusType,
+                    statusCode: autotestResult.statusCode,
+                    stepCount: (_b = (_a = autotestResult.stepResults) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0,
+                });
+                yield this.sendAutotestResultWithRetry(testRunId, autotestResult).catch((err) => {
+                    var _a, _b;
+                    const normalized = (_b = (_a = err === null || err === void 0 ? void 0 : err.body) !== null && _a !== void 0 ? _a : err === null || err === void 0 ? void 0 : err.error) !== null && _b !== void 0 ? _b : err;
+                    console.error("[testit-js-commons:loadTestRun] FAILED to post final result", {
+                        testRunId,
+                        autoTestExternalId: autotestResult.autoTestExternalId,
+                        error: normalized,
+                    });
+                });
+            }
+        });
+    }
+    sendAutotestResultWithRetry(testRunId, autotestResult) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const maxAttempts = 3;
+            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                try {
+                    yield this._client.setAutoTestResultsForTestRun(testRunId, { autoTestResultsForTestRunModel: [autotestResult] });
+                    return;
+                }
+                catch (err) {
+                    const code = err === null || err === void 0 ? void 0 : err.code;
+                    const status = (_a = err === null || err === void 0 ? void 0 : err.status) !== null && _a !== void 0 ? _a : err === null || err === void 0 ? void 0 : err.statusCode;
+                    const msg = String((_c = (_b = err === null || err === void 0 ? void 0 : err.message) !== null && _b !== void 0 ? _b : err) !== null && _c !== void 0 ? _c : "");
+                    const transient = code === "ECONNRESET" ||
+                        code === "ETIMEDOUT" ||
+                        code === "EPIPE" ||
+                        code === "ECONNABORTED" ||
+                        msg.includes("socket hang up") ||
+                        msg.includes("read ECONNRESET") ||
+                        (typeof status === "number" && status >= 500);
+                    if (!transient || attempt === maxAttempts) {
+                        throw err;
+                    }
+                    yield new Promise((resolve) => setTimeout(resolve, 300 * attempt));
+                }
             }
         });
     }

package/lib/services/testruns/testruns.type.d.ts

@@ -58,6 +58,8 @@ export interface ITestRunsService {
     updateTestRun(testRun: TestRunGet): Promise<void>;
     startTestRun(testRunId: TestRunId): Promise<void>;
     completeTestRun(testRunId: TestRunId): Promise<void>;
+    /** First TMS write as InProgress (mirrors Python realtime in-progress before final load). */
+    postInProgressAutotestResult(testRunId: string, result: AutotestResult): Promise<void>;
     loadAutotests(testRunId: string, autotests: Array<AutotestResult>): Promise<void>;
 }
 export {};

package/lib/strategy/base.strategy.d.ts

@@ -4,13 +4,17 @@ import { AutotestPost, AutotestResult, TestRunId } from "../services";
 import { IStrategy } from "./strategy.type";
 export declare class BaseStrategy implements IStrategy {
     protected config: AdapterConfig;
+    private static readonly INPROGRESS_FIRST_GRACE_MS;
     client: IClient;
     testRunId: Promise<TestRunId>;
+    private syncStorageRunner?;
     protected constructor(config: AdapterConfig);
     setup(): Promise<void>;
     teardown(): Promise<void>;
     loadAutotest(autotest: AutotestPost, status: string): Promise<void>;
     private updateTestLinkToWorkItems;
     loadTestRun(autotests: AutotestResult[]): Promise<void>;
+    private tryStartSyncStorage;
     protected updateTestRun(config: AdapterConfig): Promise<void>;
+    private getInProgressFirstGraceMs;
 }