@allurereport/plugin-testops 3.16.0 → 3.17.0

package/README.md

@@ -80,6 +80,8 @@ The plugin accepts the following options:
 | `autocloseLaunch`  | When `true` (default), the launch is closed automatically when the plugin finishes; set to `false` to keep the launch open | `boolean` | `true`          |
 | `gitFlow`          | When `true`, collect Git metadata for TestOps Git Flow on CI uploads (opt-in)                                 | `boolean` | `false`         |
 | `ancestorLimit`    | How many ancestor commits to attach to the launch for history linking in TestOps | `number`  | `100`           |
+| `uploadRateLimit`  | Caps how fast uploads are sent to TestOps within a rolling time window (requests/files/bytes per window); pass `false` to disable pacing entirely | `{ windowMs: number; maxRequestsPerWindow?: number; maxFilesPerWindow?: number; maxBytesPerWindow?: number } \| false` | `20` req/s, `1000` files/s, `1 GiB`/s |
+| `reopenClosedLaunch` | When `true`, a launch that TestOps reports as closed is reopened automatically instead of failing the upload | `boolean` | `false`         |
 
 ### Using options from environment variables
 

package/dist/client.d.ts

@@ -2,6 +2,7 @@ import type { ClientRequest } from "http";
 import type { AttachmentLink, CiDescriptor, EnvironmentIdentity, TestError, TestResult, TestStatus } from "@allurereport/core-api";
 import type { QualityGateValidationResult } from "@allurereport/plugin-api";
 import { AxiosError, type AxiosResponse } from "axios";
+import type { RetryOptions } from "./errors.js";
 import type { LaunchGitContextDto } from "./gitFlow/index.js";
 import type { AttachmentForUpload, AttachmentsResolver, FixtureResolver, LaunchCategoryBulkItem, LaunchCategoryBulkResult, TestOpsClientParams, TestOpsNamedEnv, TestOpsPluginTestResult } from "./model.js";
 declare class TestOpsClientError extends AxiosError<{
@@ -23,13 +24,14 @@ export declare class TestOpsClient {
     get launchUrl(): string | undefined;
     get launchId(): number | undefined;
     closeLaunch(launchId: number): Promise<void>;
+    reopenLaunch(launchId: number): Promise<void>;
     createLaunchCategoriesBulk(launchId: number, items: LaunchCategoryBulkItem[]): Promise<LaunchCategoryBulkResult[]>;
-    startUpload(ci: CiDescriptor): Promise<void>;
+    startUpload(ci: CiDescriptor, jobRunId?: number): Promise<void>;
     stopUpload(ci: CiDescriptor, status: TestStatus): Promise<void>;
     createLaunch(launchName: string, launchTags: string[], gitContext?: LaunchGitContextDto): Promise<void>;
+    attachToLaunch(launchId: number): void;
     checkLaunchProgress(): Promise<boolean>;
-    createSession(environment?: Record<string, unknown>): Promise<void>;
-    get namedEnvs(): MapIterator<TestOpsNamedEnv>;
+    createSession(environment?: Record<string, unknown>, reopenClosedLaunch?: boolean): Promise<void>;
     getNamedEnvFor(id: string): TestOpsNamedEnv | undefined;
     createNamedEnvs(environments: EnvironmentIdentity[], onProgress?: (percent: number, total: number) => void): Promise<void>;
     uploadGlobalAttachments(params: {
@@ -44,6 +46,8 @@ export declare class TestOpsClient {
         attachmentsResolver: AttachmentsResolver;
         fixturesResolver: FixtureResolver;
         onProgress?: () => void;
+        onRetry?: RetryOptions["onRetry"];
+        onChunkUploaded?: (uploadedChunkTrs: TestResult[]) => void;
     }): Promise<TestResult[]>;
     uploadQualityGateResults(results: QualityGateValidationResult[], onProgress?: (percent: number, total: number) => void): Promise<void>;
 }

package/dist/client.js

@@ -9,65 +9,29 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _TestOpsClient_instances, _TestOpsClient_baseUrl, _TestOpsClient_logger, _TestOpsClient_accessToken, _TestOpsClient_projectId, _TestOpsClient_client, _TestOpsClient_launch, _TestOpsClient_session, _TestOpsClient_uploadInProgress, _TestOpsClient_uploadLimit, _TestOpsClient_namedEnvsIdsByEnv, _TestOpsClient_postTestResultsChunk, _TestOpsClient_uploadChunkAttachmentsAndFixtures, _TestOpsClient_uploadAttachmentsForResult, _TestOpsClient_uploadFixturesForResult;
-import { createServiceHttpClient } from "@allurereport/service";
+var _TestOpsClient_instances, _TestOpsClient_baseUrl, _TestOpsClient_logger, _TestOpsClient_accessToken, _TestOpsClient_projectId, _TestOpsClient_client, _TestOpsClient_launch, _TestOpsClient_jobRunId, _TestOpsClient_session, _TestOpsClient_uploadInProgress, _TestOpsClient_uploadLimit, _TestOpsClient_uploadPacer, _TestOpsClient_namedEnvsIdsByEnv, _TestOpsClient_getExistingJob, _TestOpsClient_postTestResultsChunk, _TestOpsClient_uploadChunkAttachmentsAndFixtures, _TestOpsClient_uploadAttachmentsForResult, _TestOpsClient_logResultUploadFailure, _TestOpsClient_uploadFixturesForResult;
+import { isLocalCiDescriptor } from "@allurereport/ci";
+import { KnownError, createServiceHttpClient } from "@allurereport/service";
 import { AxiosError, isAxiosError } from "axios";
 import FormData from "form-data";
 import { chunk } from "lodash-es";
 import pLimit from "p-limit";
 import { bold } from "yoctocolors";
+import { withUploadRetry } from "./errors.js";
 import { Logger } from "./logger.js";
+import { UploadPacer } from "./uploadPacer.js";
 import { toUploadFixturesResultsDto } from "./utils/fixtures.js";
+import { attachmentByteLength, retryRequest } from "./utils/httpRetry.js";
+import { TESTOPS_CI_TYPE, ciEndpoint, externalParameters } from "./utils/jobParameters.js";
 import { testStatusToLaunchStatus } from "./utils/launches.js";
 import { normalizeTestStepsResults, toUploadResultsDto } from "./utils/testResults.js";
 import { validateExecutableName } from "./utils/validation.js";
 class TestOpsClientError extends AxiosError {
 }
+const UNKNOWN_ERROR_MESSAGE = "Unknown error";
+const MAX_LAUNCH_NAME_LENGTH = 255;
 const CHUNK_SIZE = 100;
 const BULK_UPLOAD_CHUNK_SIZE = 1000;
-const MAX_REQUEST_RETRIES = 3;
-const RETRY_BASE_DELAY_MS = 500;
-const getAxiosCause = (error) => {
-    if (isAxiosError(error)) {
-        return error;
-    }
-    return error instanceof Error && isAxiosError(error.cause) ? error.cause : undefined;
-};
-const isRetryableRequestError = (error) => {
-    const cause = getAxiosCause(error);
-    if (!cause || cause.code === "ERR_CANCELED" || cause.name === "CanceledError") {
-        return false;
-    }
-    const status = cause.response?.status;
-    return status === undefined || status === 408 || status === 429 || status >= 500;
-};
-const retryAfterMs = (error) => {
-    const headers = getAxiosCause(error)?.response?.headers;
-    const value = typeof headers?.get === "function" ? headers.get("retry-after") : headers?.["retry-after"];
-    const normalized = Array.isArray(value) ? value[0] : value;
-    if (typeof normalized !== "string" && typeof normalized !== "number") {
-        return undefined;
-    }
-    const seconds = Number(normalized);
-    if (Number.isFinite(seconds)) {
-        return Math.max(0, seconds * 1000);
-    }
-    const date = Date.parse(String(normalized));
-    return Number.isNaN(date) ? undefined : Math.max(0, date - Date.now());
-};
-const retryRequest = async (request) => {
-    for (let attempt = 0;; attempt += 1) {
-        try {
-            return await request();
-        }
-        catch (error) {
-            if (attempt >= MAX_REQUEST_RETRIES || !isRetryableRequestError(error)) {
-                throw error;
-            }
-            await new Promise((resolve) => setTimeout(resolve, retryAfterMs(error) ?? RETRY_BASE_DELAY_MS * 2 ** attempt));
-        }
-    }
-};
 export class TestOpsClient {
     constructor(params) {
         _TestOpsClient_instances.add(this);
@@ -77,9 +41,11 @@ export class TestOpsClient {
         _TestOpsClient_projectId.set(this, void 0);
         _TestOpsClient_client.set(this, void 0);
         _TestOpsClient_launch.set(this, void 0);
+        _TestOpsClient_jobRunId.set(this, void 0);
         _TestOpsClient_session.set(this, void 0);
         _TestOpsClient_uploadInProgress.set(this, false);
         _TestOpsClient_uploadLimit.set(this, 1);
+        _TestOpsClient_uploadPacer.set(this, void 0);
         _TestOpsClient_namedEnvsIdsByEnv.set(this, new Map());
         if (!params.accessToken) {
             throw new Error("accessToken is required");
@@ -102,6 +68,7 @@ export class TestOpsClient {
         if (params.limit) {
             __classPrivateFieldSet(this, _TestOpsClient_uploadLimit, params.limit, "f");
         }
+        __classPrivateFieldSet(this, _TestOpsClient_uploadPacer, new UploadPacer(params.uploadRateLimit), "f");
     }
     isTestOpsClientError(error) {
         return (isAxiosError(error) &&
@@ -122,6 +89,11 @@ export class TestOpsClient {
         await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post(`/api/launch/${launchId}/close`);
         __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose("Launch closed");
     }
+    async reopenLaunch(launchId) {
+        __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose(`Reopening launch ${launchId}…`);
+        await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post(`/api/launch/${launchId}/reopen`);
+        __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose("Launch reopened");
+    }
     async createLaunchCategoriesBulk(launchId, items) {
         if (items.length === 0) {
             return [];
@@ -157,29 +129,52 @@ export class TestOpsClient {
         }
         return results;
     }
-    async startUpload(ci) {
-        if (!__classPrivateFieldGet(this, _TestOpsClient_launch, "f")) {
+    async startUpload(ci, jobRunId) {
+        if (!jobRunId && !__classPrivateFieldGet(this, _TestOpsClient_launch, "f")) {
             throw new Error("Launch isn't created! Call createLaunch first");
         }
+        if (!jobRunId && isLocalCiDescriptor(ci)) {
+            __classPrivateFieldSet(this, _TestOpsClient_uploadInProgress, true, "f");
+            __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose("CI upload started (manual, no CI detected)");
+            return;
+        }
+        const endpoint = ciEndpoint(ci);
+        const existingJob = await __classPrivateFieldGet(this, _TestOpsClient_instances, "m", _TestOpsClient_getExistingJob).call(this, ci);
+        const parameters = externalParameters(ci, existingJob?.parameters);
+        const jobPayload = {
+            name: ci.jobName || ci.jobUid,
+            uid: ci.jobUid,
+            ...(existingJob?.id ? { id: existingJob.id } : {}),
+            ...(ci.jobUrl ? { url: ci.jobUrl } : {}),
+            ...(parameters.job.length ? { parameters: parameters.job } : {}),
+        };
+        const jobRunPayload = {
+            ...(jobRunId ? { id: jobRunId } : {}),
+            uid: ci.jobRunUid,
+            ...(ci.jobRunName ? { name: ci.jobRunName } : {}),
+            ...(ci.jobRunUrl ? { url: ci.jobRunUrl } : {}),
+            ...(parameters.jobRun.length ? { parameters: parameters.jobRun } : {}),
+        };
         __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose(`Starting CI upload (${ci.type})…`);
-        await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/upload/start", {
+        const data = await retryRequest(() => __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/upload/start", {
             body: {
                 projectId: __classPrivateFieldGet(this, _TestOpsClient_projectId, "f"),
                 ci: {
-                    name: ci.type,
-                },
-                job: {
-                    name: ci.jobUid,
-                    uid: ci.jobUid,
-                },
-                jobRun: {
-                    uid: ci.jobRunUid,
-                },
-                launch: {
-                    id: __classPrivateFieldGet(this, _TestOpsClient_launch, "f").id,
+                    type: TESTOPS_CI_TYPE[ci.type] ?? ci.type,
+                    ...(endpoint ? { endpoint } : {}),
                 },
+                job: jobPayload,
+                jobRun: jobRunPayload,
+                ...(__classPrivateFieldGet(this, _TestOpsClient_launch, "f") ? { launch: { id: __classPrivateFieldGet(this, _TestOpsClient_launch, "f").id } } : {}),
             },
-        });
+        }));
+        __classPrivateFieldSet(this, _TestOpsClient_jobRunId, data?.jobRunId ?? jobRunId, "f");
+        if (jobRunId) {
+            if (typeof data?.launchId !== "number") {
+                throw new Error("TestOps didn't return a launch id for the job run");
+            }
+            __classPrivateFieldSet(this, _TestOpsClient_launch, { id: data.launchId }, "f");
+        }
         __classPrivateFieldSet(this, _TestOpsClient_uploadInProgress, true, "f");
         __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose("CI upload started");
     }
@@ -187,14 +182,16 @@ export class TestOpsClient {
         if (!__classPrivateFieldGet(this, _TestOpsClient_uploadInProgress, "f")) {
             throw new Error("Upload isn't started! Call startUpload first");
         }
-        await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/upload/stop", {
-            body: {
-                jobRunUid: ci.jobRunUid,
-                jobUid: ci.jobUid,
-                projectId: __classPrivateFieldGet(this, _TestOpsClient_projectId, "f"),
-                status: testStatusToLaunchStatus(status),
-            },
-        });
+        if (!isLocalCiDescriptor(ci)) {
+            await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/upload/stop", {
+                body: {
+                    jobRunUid: ci.jobRunUid,
+                    jobUid: ci.jobUid,
+                    projectId: __classPrivateFieldGet(this, _TestOpsClient_projectId, "f"),
+                    status: testStatusToLaunchStatus(status),
+                },
+            });
+        }
         __classPrivateFieldSet(this, _TestOpsClient_uploadInProgress, false, "f");
         __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose(`CI upload stopped (status: ${status})`);
     }
@@ -202,7 +199,7 @@ export class TestOpsClient {
         __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose("Creating launch…");
         const data = await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/launch", {
             body: {
-                name: launchName,
+                name: launchName.slice(0, MAX_LAUNCH_NAME_LENGTH),
                 projectId: __classPrivateFieldGet(this, _TestOpsClient_projectId, "f"),
                 autoclose: true,
                 external: true,
@@ -213,6 +210,9 @@ export class TestOpsClient {
         __classPrivateFieldSet(this, _TestOpsClient_launch, data, "f");
         __classPrivateFieldGet(this, _TestOpsClient_logger, "f").debug(`Launch created: id=${bold(data.id.toString())}`);
     }
+    attachToLaunch(launchId) {
+        __classPrivateFieldSet(this, _TestOpsClient_launch, { id: launchId }, "f");
+    }
     async checkLaunchProgress() {
         if (!__classPrivateFieldGet(this, _TestOpsClient_launch, "f")) {
             throw new Error("Launch isn't created! Call createLaunch first");
@@ -221,34 +221,33 @@ export class TestOpsClient {
         const data = await retryRequest(() => __classPrivateFieldGet(this, _TestOpsClient_client, "f").get(`/api/launch/${__classPrivateFieldGet(this, _TestOpsClient_launch, "f").id}/progress`));
         return data.ready;
     }
-    async createSession(environment = {}) {
+    async createSession(environment = {}, reopenClosedLaunch = false) {
         if (!__classPrivateFieldGet(this, _TestOpsClient_launch, "f")) {
             throw new Error("Launch isn't created! Call createLaunch first");
         }
-        const data = await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/upload/session", {
-            body: {
-                launchId: __classPrivateFieldGet(this, _TestOpsClient_launch, "f").id,
-                environment: Object.entries(environment).map(([key, value]) => ({
-                    key,
-                    value: String(value),
-                })),
-            },
-            params: {
-                manual: "true",
-            },
-        });
+        const currentLaunch = await retryRequest(() => __classPrivateFieldGet(this, _TestOpsClient_client, "f").get(`/api/launch/${__classPrivateFieldGet(this, _TestOpsClient_launch, "f").id}`));
+        if (currentLaunch.closed) {
+            if (!reopenClosedLaunch) {
+                throw new Error(`Launch ${__classPrivateFieldGet(this, _TestOpsClient_launch, "f").id} is closed`);
+            }
+            await this.reopenLaunch(__classPrivateFieldGet(this, _TestOpsClient_launch, "f").id);
+        }
+        const sessionEnvironment = Object.entries(environment).map(([key, value]) => ({
+            key,
+            value: String(value),
+        }));
+        const data = __classPrivateFieldGet(this, _TestOpsClient_jobRunId, "f")
+            ? await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/upload/session", {
+                body: { jobRunId: __classPrivateFieldGet(this, _TestOpsClient_jobRunId, "f"), environment: sessionEnvironment },
+            })
+            : await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/upload/session", {
+                body: { launchId: __classPrivateFieldGet(this, _TestOpsClient_launch, "f").id, environment: sessionEnvironment },
+                params: { manual: "true" },
+            });
         __classPrivateFieldSet(this, _TestOpsClient_session, data, "f");
     }
-    get namedEnvs() {
-        return __classPrivateFieldGet(this, _TestOpsClient_namedEnvsIdsByEnv, "f").values();
-    }
     getNamedEnvFor(id) {
-        for (const [, env] of __classPrivateFieldGet(this, _TestOpsClient_namedEnvsIdsByEnv, "f")) {
-            if (env.externalId === id) {
-                return env;
-            }
-        }
-        return undefined;
+        return __classPrivateFieldGet(this, _TestOpsClient_namedEnvsIdsByEnv, "f").get(id);
     }
     async createNamedEnvs(environments, onProgress) {
         if (!__classPrivateFieldGet(this, _TestOpsClient_session, "f")) {
@@ -293,11 +292,13 @@ export class TestOpsClient {
         const launchId = __classPrivateFieldGet(this, _TestOpsClient_launch, "f").id;
         const formData = new FormData();
         let hasResolvedAttachments = false;
+        let totalBytes = 0;
         for (const attachmentLink of attachments) {
             const attachment = await attachmentsResolver(attachmentLink);
             if (!attachment) {
                 continue;
             }
+            totalBytes += attachmentByteLength(attachment);
             formData.append("file", attachment.content, {
                 filename: attachment.originalFileName,
                 contentType: attachment.contentType,
@@ -307,6 +308,7 @@ export class TestOpsClient {
         if (!hasResolvedAttachments) {
             return;
         }
+        await __classPrivateFieldGet(this, _TestOpsClient_uploadPacer, "f").wait({ requests: 1, files: attachments.length, bytes: totalBytes });
         await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/launch/attachment", {
             body: formData,
             onUploadProgress(progressEvent) {
@@ -314,7 +316,7 @@ export class TestOpsClient {
                 const percent = total > 0 ? Math.min(100, Math.max(0, (progressEvent.loaded / total) * 100)) : 0;
                 onProgress?.(percent, total);
             },
-            params: { launchId },
+            params: { launchId, ...(__classPrivateFieldGet(this, _TestOpsClient_session, "f").jobRunId ? { jobRunId: __classPrivateFieldGet(this, _TestOpsClient_session, "f").jobRunId } : {}) },
             headers: formData.getHeaders(),
         });
     }
@@ -326,10 +328,12 @@ export class TestOpsClient {
             throw new Error("Launch isn't created! Call createLaunch first");
         }
         const launchId = __classPrivateFieldGet(this, _TestOpsClient_launch, "f").id;
+        await __classPrivateFieldGet(this, _TestOpsClient_uploadPacer, "f").wait({ requests: 1 });
         await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/launch/error/bulk", {
             body: {
                 launchId,
-                items: errors,
+                ...(__classPrivateFieldGet(this, _TestOpsClient_session, "f").jobRunId ? { jobRunId: __classPrivateFieldGet(this, _TestOpsClient_session, "f").jobRunId } : {}),
+                items: errors.map(({ message, trace }) => ({ message: message?.trim() || UNKNOWN_ERROR_MESSAGE, trace })),
             },
             onUploadProgress(progressEvent) {
                 const total = progressEvent.total ?? 100;
@@ -342,7 +346,7 @@ export class TestOpsClient {
         if (!__classPrivateFieldGet(this, _TestOpsClient_session, "f")) {
             throw new Error("Session isn't created! Call createSession first");
         }
-        const { trs, environments, attachmentsResolver, fixturesResolver, onProgress } = params;
+        const { trs, environments, attachmentsResolver, fixturesResolver, onProgress, onRetry, onChunkUploaded } = params;
         const projectedTrs = trs.map((tr) => ({
             ...tr,
             ...(tr.steps ? { steps: normalizeTestStepsResults(tr.steps) } : {}),
@@ -351,39 +355,31 @@ export class TestOpsClient {
         const uploadLimitFn = pLimit(__classPrivateFieldGet(this, _TestOpsClient_uploadLimit, "f"));
         const uploadedTrs = [];
         const envNamesById = new Map(environments.map(({ id, name }) => [id, name]));
-        try {
-            for (const trsChunk of trsChunks) {
-                const chunkEnvs = new Map();
-                for (const tr of trsChunk) {
-                    const environmentId = tr.environment;
-                    if (environmentId && !__classPrivateFieldGet(this, _TestOpsClient_namedEnvsIdsByEnv, "f").has(environmentId)) {
-                        chunkEnvs.set(environmentId, {
-                            id: environmentId,
-                            name: envNamesById.get(environmentId) ?? environmentId,
-                        });
-                    }
+        for (const trsChunk of trsChunks) {
+            const chunkEnvs = new Map();
+            for (const tr of trsChunk) {
+                const environmentId = tr.environment;
+                if (environmentId && !__classPrivateFieldGet(this, _TestOpsClient_namedEnvsIdsByEnv, "f").has(environmentId)) {
+                    chunkEnvs.set(environmentId, {
+                        id: environmentId,
+                        name: envNamesById.get(environmentId) ?? environmentId,
+                    });
                 }
-                if (chunkEnvs.size > 0) {
-                    await this.createNamedEnvs(Array.from(chunkEnvs.values()));
-                }
-                const reportIdsToTestOpsIds = await __classPrivateFieldGet(this, _TestOpsClient_instances, "m", _TestOpsClient_postTestResultsChunk).call(this, trsChunk);
-                uploadedTrs.push(...trsChunk.filter((tr) => typeof reportIdsToTestOpsIds[tr.id] === "number"));
-                await __classPrivateFieldGet(this, _TestOpsClient_instances, "m", _TestOpsClient_uploadChunkAttachmentsAndFixtures).call(this, trsChunk, reportIdsToTestOpsIds, attachmentsResolver, fixturesResolver, uploadLimitFn, onProgress);
-            }
-            __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose("Test results upload completed");
-        }
-        catch (error) {
-            if (this.isTestOpsClientError(error)) {
-                __classPrivateFieldGet(this, _TestOpsClient_logger, "f").error(`Failed to upload test results: ${error.response?.data.message}`);
-                __classPrivateFieldGet(this, _TestOpsClient_logger, "f").debug(error.response.data);
-            }
-            else if (error instanceof Error) {
-                __classPrivateFieldGet(this, _TestOpsClient_logger, "f").error(`Failed to upload test results: ${error.message}`);
             }
-            else {
-                __classPrivateFieldGet(this, _TestOpsClient_logger, "f").error("Failed to upload test results");
-            }
-        }
+            const reportIdsToTestOpsIds = await withUploadRetry(async () => {
+                const envsToCreate = Array.from(chunkEnvs.values()).filter((environment) => !__classPrivateFieldGet(this, _TestOpsClient_namedEnvsIdsByEnv, "f").has(environment.id));
+                if (envsToCreate.length > 0) {
+                    await this.createNamedEnvs(envsToCreate);
+                }
+                await __classPrivateFieldGet(this, _TestOpsClient_uploadPacer, "f").wait({ requests: 1, files: trsChunk.length });
+                return __classPrivateFieldGet(this, _TestOpsClient_instances, "m", _TestOpsClient_postTestResultsChunk).call(this, trsChunk);
+            }, { onRetry });
+            const uploadedChunkTrs = trsChunk.filter((tr) => typeof reportIdsToTestOpsIds[tr.id] === "number");
+            uploadedTrs.push(...uploadedChunkTrs);
+            onChunkUploaded?.(uploadedChunkTrs);
+            await __classPrivateFieldGet(this, _TestOpsClient_instances, "m", _TestOpsClient_uploadChunkAttachmentsAndFixtures).call(this, trsChunk, reportIdsToTestOpsIds, attachmentsResolver, fixturesResolver, uploadLimitFn, onProgress);
+        }
+        __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose("Test results upload completed");
         return uploadedTrs;
     }
     async uploadQualityGateResults(results, onProgress) {
@@ -405,6 +401,7 @@ export class TestOpsClient {
             }
             return item;
         });
+        await __classPrivateFieldGet(this, _TestOpsClient_uploadPacer, "f").wait({ requests: 1 });
         await retryRequest(() => __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/launch/quality-gate/bulk", {
             body: {
                 launchId,
@@ -418,7 +415,19 @@ export class TestOpsClient {
         }));
     }
 }
-_TestOpsClient_baseUrl = new WeakMap(), _TestOpsClient_logger = new WeakMap(), _TestOpsClient_accessToken = new WeakMap(), _TestOpsClient_projectId = new WeakMap(), _TestOpsClient_client = new WeakMap(), _TestOpsClient_launch = new WeakMap(), _TestOpsClient_session = new WeakMap(), _TestOpsClient_uploadInProgress = new WeakMap(), _TestOpsClient_uploadLimit = new WeakMap(), _TestOpsClient_namedEnvsIdsByEnv = new WeakMap(), _TestOpsClient_instances = new WeakSet(), _TestOpsClient_postTestResultsChunk = async function _TestOpsClient_postTestResultsChunk(trsChunk) {
+_TestOpsClient_baseUrl = new WeakMap(), _TestOpsClient_logger = new WeakMap(), _TestOpsClient_accessToken = new WeakMap(), _TestOpsClient_projectId = new WeakMap(), _TestOpsClient_client = new WeakMap(), _TestOpsClient_launch = new WeakMap(), _TestOpsClient_jobRunId = new WeakMap(), _TestOpsClient_session = new WeakMap(), _TestOpsClient_uploadInProgress = new WeakMap(), _TestOpsClient_uploadLimit = new WeakMap(), _TestOpsClient_uploadPacer = new WeakMap(), _TestOpsClient_namedEnvsIdsByEnv = new WeakMap(), _TestOpsClient_instances = new WeakSet(), _TestOpsClient_getExistingJob = async function _TestOpsClient_getExistingJob(ci) {
+    try {
+        return await retryRequest(() => __classPrivateFieldGet(this, _TestOpsClient_client, "f").get("/api/rs/job", {
+            params: { projectId: __classPrivateFieldGet(this, _TestOpsClient_projectId, "f"), externalId: ci.jobUid },
+        }));
+    }
+    catch (error) {
+        if (error instanceof KnownError && error.status === 404) {
+            return undefined;
+        }
+        throw error;
+    }
+}, _TestOpsClient_postTestResultsChunk = async function _TestOpsClient_postTestResultsChunk(trsChunk) {
     const extendedChunk = trsChunk.map((testResult) => {
         const extendedTestResult = {
             ...testResult,
@@ -438,10 +447,10 @@ _TestOpsClient_baseUrl = new WeakMap(), _TestOpsClient_logger = new WeakMap(), _
         return extendedTestResult;
     });
     const body = toUploadResultsDto(__classPrivateFieldGet(this, _TestOpsClient_session, "f").id, extendedChunk);
-    const data = await retryRequest(() => __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/upload/test-result", {
+    const data = await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/upload/test-result", {
         body,
         headers: { "Content-Type": "application/json" },
-    }));
+    });
     const reportIdsToTestOpsIds = {};
     for (const { id, uuid } of data.results ?? []) {
         if (typeof uuid === "string" && typeof id === "number") {
@@ -455,16 +464,23 @@ _TestOpsClient_baseUrl = new WeakMap(), _TestOpsClient_logger = new WeakMap(), _
         if (typeof testOpsId !== "number") {
             return;
         }
-        const attachments = await attachmentsResolver(tr);
-        const fixtures = (await fixturesResolver(tr))
-            .filter((fixture) => validateExecutableName(fixture.name))
-            .map((fixture) => ({
-            ...fixture,
-            ...(fixture.steps ? { steps: normalizeTestStepsResults(fixture.steps) } : {}),
-        }));
-        await __classPrivateFieldGet(this, _TestOpsClient_instances, "m", _TestOpsClient_uploadAttachmentsForResult).call(this, testOpsId, attachments);
-        await __classPrivateFieldGet(this, _TestOpsClient_instances, "m", _TestOpsClient_uploadFixturesForResult).call(this, testOpsId, fixtures);
-        onProgress?.();
+        try {
+            const attachments = await attachmentsResolver(tr);
+            const fixtures = (await fixturesResolver(tr))
+                .filter((fixture) => validateExecutableName(fixture.name))
+                .map((fixture) => ({
+                ...fixture,
+                ...(fixture.steps ? { steps: normalizeTestStepsResults(fixture.steps) } : {}),
+            }));
+            await __classPrivateFieldGet(this, _TestOpsClient_instances, "m", _TestOpsClient_uploadAttachmentsForResult).call(this, testOpsId, attachments);
+            await __classPrivateFieldGet(this, _TestOpsClient_instances, "m", _TestOpsClient_uploadFixturesForResult).call(this, testOpsId, fixtures);
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _TestOpsClient_instances, "m", _TestOpsClient_logResultUploadFailure).call(this, "fixtures", testOpsId, error);
+        }
+        finally {
+            onProgress?.();
+        }
     })));
 }, _TestOpsClient_uploadAttachmentsForResult = async function _TestOpsClient_uploadAttachmentsForResult(testOpsResultId, attachments) {
     if (attachments.length === 0) {
@@ -473,35 +489,41 @@ _TestOpsClient_baseUrl = new WeakMap(), _TestOpsClient_logger = new WeakMap(), _
     const attachmentsChunks = chunk(attachments, 100);
     for (const attachmentsChunk of attachmentsChunks) {
         const formData = new FormData();
+        let chunkBytes = 0;
         for (const att of attachmentsChunk) {
+            chunkBytes += attachmentByteLength(att);
             formData.append("file", att.content, {
                 filename: att.originalFileName,
                 contentType: att.contentType,
             });
         }
         try {
+            await __classPrivateFieldGet(this, _TestOpsClient_uploadPacer, "f").wait({ requests: 1, files: attachmentsChunk.length, bytes: chunkBytes });
             await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post(`/api/upload/test-result/${testOpsResultId}/attachment`, {
                 body: formData,
                 headers: formData.getHeaders(),
             });
         }
         catch (error) {
-            if (this.isTestOpsClientError(error)) {
-                __classPrivateFieldGet(this, _TestOpsClient_logger, "f").error(`Failed to upload attachments for result ${testOpsResultId}: ${error.response?.data.message}`);
-            }
-            else if (error instanceof Error) {
-                __classPrivateFieldGet(this, _TestOpsClient_logger, "f").error(`Failed to upload attachments for result ${testOpsResultId}: ${error.message}`);
-            }
-            else {
-                __classPrivateFieldGet(this, _TestOpsClient_logger, "f").error(`Failed to upload attachments for result ${testOpsResultId}`);
-            }
+            __classPrivateFieldGet(this, _TestOpsClient_instances, "m", _TestOpsClient_logResultUploadFailure).call(this, "attachments", testOpsResultId, error);
             __classPrivateFieldGet(this, _TestOpsClient_logger, "f").inspect(formData);
         }
     }
+}, _TestOpsClient_logResultUploadFailure = function _TestOpsClient_logResultUploadFailure(label, testOpsResultId, error) {
+    if (this.isTestOpsClientError(error)) {
+        __classPrivateFieldGet(this, _TestOpsClient_logger, "f").error(`Failed to upload ${label} for result ${testOpsResultId}: ${error.response?.data.message}`);
+    }
+    else if (error instanceof Error) {
+        __classPrivateFieldGet(this, _TestOpsClient_logger, "f").error(`Failed to upload ${label} for result ${testOpsResultId}: ${error.message}`);
+    }
+    else {
+        __classPrivateFieldGet(this, _TestOpsClient_logger, "f").error(`Failed to upload ${label} for result ${testOpsResultId}`);
+    }
 }, _TestOpsClient_uploadFixturesForResult = async function _TestOpsClient_uploadFixturesForResult(testOpsResultId, fixtures) {
     if (fixtures.length === 0)
         return;
     const body = toUploadFixturesResultsDto(fixtures);
+    await __classPrivateFieldGet(this, _TestOpsClient_uploadPacer, "f").wait({ requests: 1 });
     await retryRequest(() => __classPrivateFieldGet(this, _TestOpsClient_client, "f").post(`/api/upload/test-result/${testOpsResultId}/test-fixture-result`, {
         body,
     }));

package/dist/errors.d.ts

@@ -0,0 +1,23 @@
+export declare enum ErrorKind {
+    None = "none",
+    ServiceTransient = "service_transient",
+    ResourceRecoverable = "resource_recoverable",
+    AuthTerminal = "auth_terminal",
+    NotFoundTerminal = "not_found_terminal",
+    PayloadTerminal = "payload_terminal",
+    ValidationTerminal = "validation_terminal",
+    ConflictTerminal = "conflict_terminal",
+    Unknown = "unknown"
+}
+export declare const isClosedLaunchError: (error: unknown) => boolean;
+export declare const classifyError: (error: unknown) => ErrorKind;
+export declare const shouldRetryUpload: (error: unknown) => boolean;
+export declare const isPermanentUploadError: (error: unknown) => boolean;
+export declare const isTerminalUploadError: (error: unknown, retries: number, maxRetries: number) => boolean;
+export type RetryOptions = {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    onRetry?: (error: unknown, attempt: number) => void | Promise<void>;
+};
+export declare const withUploadRetry: <T>(operation: () => Promise<T>, options?: RetryOptions) => Promise<T>;