@allurereport/plugin-testops 3.3.1 → 3.4.1

package/README.md

@@ -51,13 +51,14 @@ export default defineConfig({
 
 The plugin accepts the following options:
 
-| Option           | Description                                     | Type    | Default                 |
-|------------------|-------------------------------------------------|---------|-------------------------|
-| `launchName`     | Name of the report which will be assigned to the new launch                              | `string` | `Allure Report`         |
-| `launchTags`     | Tags to be assigned to the new launch                              | `string[]` | `[]`         |
-| `accessToken`    | Access token for TestOps API                    | `string` | `undefined`             |
-| `endpoint`       | TestOps API endpoint                            | `string` | `undefined` |
-| `projectId`      | TestOps project ID                              | `string` | `undefined`             |
+| Option             | Description                                                                 | Type      | Default         |
+|--------------------|-----------------------------------------------------------------------------|-----------|-----------------|
+| `launchName`       | Name of the report which will be assigned to the new launch                 | `string`  | `Allure Report` |
+| `launchTags`       | Tags to be assigned to the new launch                                      | `string[]`| `[]`            |
+| `accessToken`      | Access token for TestOps API                                               | `string`  | `undefined`     |
+| `endpoint`         | TestOps API endpoint                                                       | `string`  | `undefined`     |
+| `projectId`        | TestOps project ID                                                         | `string`  | `undefined`     |
+| `autocloseLaunch`  | When `true` (default), the launch is closed automatically when the plugin finishes; set to `false` to keep the launch open | `boolean` | `true`          |
 
 ### Using options from environment variables
 

package/dist/client.d.ts

@@ -1,22 +1,49 @@
-import type { CiDescriptor, TestResult, TestStatus } from "@allurereport/core-api";
+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 { AttachmentForUpload, AttachmentsResolver, FixtureResolver, LaunchCategoryBulkItem, LaunchCategoryBulkResult, TestOpsClientParams, TestOpsNamedEnv, TestOpsPluginTestResult } from "./model.js";
+declare class TestOpsClientError extends AxiosError<{
+    message: string;
+    timestamp: number;
+    status: number;
+}> {
+    response: AxiosResponse<{
+        message: string;
+        timestamp: number;
+        status: number;
+    }>;
+    request: ClientRequest;
+}
 export declare class TestOpsClient {
     #private;
-    constructor(params: {
-        baseUrl: string;
-        projectId: string;
-        accessToken: string;
-        limit?: number;
-    });
+    constructor(params: TestOpsClientParams);
+    isTestOpsClientError(error: unknown): error is TestOpsClientError;
     get launchUrl(): string | undefined;
+    get launchId(): number | undefined;
+    closeLaunch(launchId: number): Promise<void>;
+    createLaunchCategoriesBulk(launchId: number, items: LaunchCategoryBulkItem[]): Promise<LaunchCategoryBulkResult[]>;
     issueOauthToken(): Promise<void>;
     startUpload(ci: CiDescriptor): Promise<void>;
     stopUpload(ci: CiDescriptor, status: TestStatus): Promise<void>;
     createLaunch(launchName: string, launchTags: string[]): Promise<void>;
     createSession(environment?: Record<string, any>): Promise<void>;
+    get namedEnvs(): MapIterator<TestOpsNamedEnv>;
+    getNamedEnvFor(id: string): TestOpsNamedEnv | undefined;
+    createNamedEnvs(environments: EnvironmentIdentity[], onProgress?: (percent: number, total: number) => void): Promise<void>;
+    uploadGlobalAttachments(params: {
+        attachments: AttachmentLink[];
+        attachmentsResolver: (attachment: AttachmentLink) => Promise<AttachmentForUpload | undefined>;
+        onProgress?: (percent: number, total: number) => void;
+    }): Promise<void>;
+    uploadGlobalErrors(errors: TestError[], onProgress?: (percent: number, total: number) => void): Promise<void>;
     uploadTestResults(params: {
-        trs: TestResult[];
-        attachmentsResolver: (tr: TestResult) => Promise<any>;
-        fixturesResolver: (tr: TestResult) => Promise<any>;
+        trs: TestOpsPluginTestResult[];
+        environments: EnvironmentIdentity[];
+        attachmentsResolver: AttachmentsResolver;
+        fixturesResolver: FixtureResolver;
         onProgress?: () => void;
-    }): Promise<void>;
+    }): Promise<TestResult[]>;
+    uploadQualityGateResults(results: QualityGateValidationResult[], onProgress?: (percent: number, total: number) => void): Promise<void>;
 }
+export {};

package/dist/client.js

@@ -9,13 +9,21 @@ 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_accessToken, _TestOpsClient_projectId, _TestOpsClient_oauthToken, _TestOpsClient_client, _TestOpsClient_launch, _TestOpsClient_session, _TestOpsClient_uploadInProgress, _TestOpsClient_uploadLimit;
-import axios from "axios";
+var _TestOpsClient_instances, _TestOpsClient_logger, _TestOpsClient_accessToken, _TestOpsClient_projectId, _TestOpsClient_oauthToken, _TestOpsClient_client, _TestOpsClient_launch, _TestOpsClient_session, _TestOpsClient_uploadInProgress, _TestOpsClient_uploadLimit, _TestOpsClient_namedEnvsIdsByEnv, _TestOpsClient_postTestResultsChunk, _TestOpsClient_uploadChunkAttachmentsAndFixtures, _TestOpsClient_uploadAttachmentsForResult, _TestOpsClient_uploadFixturesForResult;
+import axios, { AxiosError, isAxiosError } from "axios";
 import FormData from "form-data";
-import chunk from "lodash.chunk";
+import { chunk } from "lodash-es";
 import pLimit from "p-limit";
+import { bold } from "yoctocolors";
+import { Logger } from "./logger.js";
+class TestOpsClientError extends AxiosError {
+}
+const CHUNK_SIZE = 100;
+const BULK_UPLOAD_CHUNK_SIZE = 1000;
 export class TestOpsClient {
     constructor(params) {
+        _TestOpsClient_instances.add(this);
+        _TestOpsClient_logger.set(this, new Logger("TestOpsClient"));
         _TestOpsClient_accessToken.set(this, void 0);
         _TestOpsClient_projectId.set(this, void 0);
         _TestOpsClient_oauthToken.set(this, "");
@@ -24,6 +32,7 @@ export class TestOpsClient {
         _TestOpsClient_session.set(this, void 0);
         _TestOpsClient_uploadInProgress.set(this, false);
         _TestOpsClient_uploadLimit.set(this, 1);
+        _TestOpsClient_namedEnvsIdsByEnv.set(this, new Map());
         if (!params.accessToken) {
             throw new Error("accessToken is required");
         }
@@ -42,28 +51,86 @@ export class TestOpsClient {
             baseURL: params.baseUrl,
             validateStatus: (status) => status >= 200 && status < 400,
         }), "f");
+        __classPrivateFieldGet(this, _TestOpsClient_client, "f").interceptors.request.use((config) => {
+            if (__classPrivateFieldGet(this, _TestOpsClient_oauthToken, "f")) {
+                config.headers.set("Authorization", `Bearer ${__classPrivateFieldGet(this, _TestOpsClient_oauthToken, "f")}`);
+            }
+            return config;
+        });
         if (params.limit) {
             __classPrivateFieldSet(this, _TestOpsClient_uploadLimit, params.limit, "f");
         }
     }
+    isTestOpsClientError(error) {
+        return (isAxiosError(error) &&
+            typeof error.response?.data.status === "number" &&
+            typeof error.response?.data.message === "string");
+    }
     get launchUrl() {
         if (!__classPrivateFieldGet(this, _TestOpsClient_launch, "f")) {
             return undefined;
         }
         return new URL(`launch/${__classPrivateFieldGet(this, _TestOpsClient_launch, "f").id}`, __classPrivateFieldGet(this, _TestOpsClient_client, "f").defaults.baseURL).toString();
     }
+    get launchId() {
+        return __classPrivateFieldGet(this, _TestOpsClient_launch, "f")?.id;
+    }
+    async closeLaunch(launchId) {
+        __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose("Closing launch…");
+        await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post(`/api/launch/${launchId}/close`);
+        __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose("Launch closed");
+    }
+    async createLaunchCategoriesBulk(launchId, items) {
+        if (items.length === 0) {
+            return [];
+        }
+        const results = [];
+        const uploadChunk = async (chunk, currentRequestIndex, totalChunks) => {
+            const body = { launchId, items: chunk };
+            if (totalChunks === 1) {
+                __classPrivateFieldGet(this, _TestOpsClient_logger, "f").debug(`POST /api/launch/category/bulk request (items: ${chunk.length})`);
+            }
+            else {
+                __classPrivateFieldGet(this, _TestOpsClient_logger, "f").debug(`POST /api/launch/category/bulk request (${currentRequestIndex + 1}/${totalChunks}, items: ${chunk.length})`);
+            }
+            __classPrivateFieldGet(this, _TestOpsClient_logger, "f").debug(body);
+            const { data } = await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/launch/category/bulk", body, {
+                headers: { "Content-Type": "application/json" },
+            });
+            if (Array.isArray(data)) {
+                results.push(...data);
+            }
+        };
+        if (items.length <= BULK_UPLOAD_CHUNK_SIZE) {
+            __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose(`Creating ${bold(items.length.toString())} launch categories…`);
+            await uploadChunk(items, 0, 1);
+        }
+        else {
+            const chunks = chunk(items, BULK_UPLOAD_CHUNK_SIZE);
+            __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose(`Creating ${bold(items.length.toString())} launch categories in ${bold(chunks.length.toString())} request(s)…`);
+            for (let i = 0; i < chunks.length; i += 1) {
+                await uploadChunk(chunks[i], i, chunks.length);
+            }
+        }
+        return results;
+    }
     async issueOauthToken() {
+        const base = __classPrivateFieldGet(this, _TestOpsClient_client, "f").defaults.baseURL;
+        __classPrivateFieldGet(this, _TestOpsClient_logger, "f").debug(`Endpoint: ${base}`);
+        __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose("Issuing OAuth token…");
         const formData = new FormData();
         formData.append("grant_type", "apitoken");
         formData.append("scope", "openid");
         formData.append("token", __classPrivateFieldGet(this, _TestOpsClient_accessToken, "f"));
         const { data } = await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/uaa/oauth/token", formData);
         __classPrivateFieldSet(this, _TestOpsClient_oauthToken, data.access_token, "f");
+        __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose("OAuth token received");
     }
     async startUpload(ci) {
         if (!__classPrivateFieldGet(this, _TestOpsClient_launch, "f")) {
             throw new Error("Launch isn't created! Call createLaunch first");
         }
+        __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose(`Starting CI upload (${ci.type})…`);
         await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/upload/start", {
             projectId: __classPrivateFieldGet(this, _TestOpsClient_projectId, "f"),
             ci: {
@@ -79,12 +146,9 @@ export class TestOpsClient {
             launch: {
                 id: __classPrivateFieldGet(this, _TestOpsClient_launch, "f").id,
             },
-        }, {
-            headers: {
-                Authorization: `Bearer ${__classPrivateFieldGet(this, _TestOpsClient_oauthToken, "f")}`,
-            },
         });
         __classPrivateFieldSet(this, _TestOpsClient_uploadInProgress, true, "f");
+        __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose("CI upload started");
     }
     async stopUpload(ci, status) {
         if (!__classPrivateFieldGet(this, _TestOpsClient_uploadInProgress, "f")) {
@@ -95,96 +159,283 @@ export class TestOpsClient {
             jobUid: ci.jobUid,
             projectId: __classPrivateFieldGet(this, _TestOpsClient_projectId, "f"),
             status,
-        }, {
-            headers: {
-                Authorization: `Bearer ${__classPrivateFieldGet(this, _TestOpsClient_oauthToken, "f")}`,
-            },
         });
         __classPrivateFieldSet(this, _TestOpsClient_uploadInProgress, false, "f");
+        __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose(`CI upload stopped (status: ${status})`);
     }
     async createLaunch(launchName, launchTags) {
+        __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose("Creating launch…");
         const { data } = await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/launch", {
             name: launchName,
             projectId: __classPrivateFieldGet(this, _TestOpsClient_projectId, "f"),
             autoclose: true,
             external: true,
             tags: launchTags.map((tag) => ({ name: tag })),
-        }, {
-            headers: {
-                Authorization: `Bearer ${__classPrivateFieldGet(this, _TestOpsClient_oauthToken, "f")}`,
-            },
         });
         __classPrivateFieldSet(this, _TestOpsClient_launch, data, "f");
+        __classPrivateFieldGet(this, _TestOpsClient_logger, "f").debug(`Launch created: id=${bold(data.id.toString())}`);
     }
     async createSession(environment = {}) {
         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?manual=true", {
+        const { data } = await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/upload/session", {
             launchId: __classPrivateFieldGet(this, _TestOpsClient_launch, "f").id,
-            environment: Object.entries(environment).map(([key, value]) => ({ key, value: String(value) })),
+            environment: Object.entries(environment).map(([key, value]) => ({
+                key,
+                value: String(value),
+            })),
         }, {
-            headers: {
-                Authorization: `Bearer ${__classPrivateFieldGet(this, _TestOpsClient_oauthToken, "f")}`,
+            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;
+    }
+    async createNamedEnvs(environments, onProgress) {
+        if (!__classPrivateFieldGet(this, _TestOpsClient_session, "f")) {
+            throw new Error("Session isn't created! Call createSession first");
+        }
+        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/launch/named-env/bulk", {
+            launchId: __classPrivateFieldGet(this, _TestOpsClient_launch, "f").id,
+            items: environments.map(({ id, name }) => ({
+                externalId: id,
+                name,
+            })),
+        }, {
+            headers: {
+                "Content-Type": "application/json",
+            },
+            onUploadProgress(progressEvent) {
+                const total = progressEvent.total ?? 100;
+                const percent = total > 0 ? Math.min(100, Math.max(0, (progressEvent.loaded / total) * 100)) : 0;
+                onProgress?.(percent, total);
+            },
+        });
+        const namesById = new Map(environments.map(({ id, name }) => [id, name]));
+        data.forEach((env) => {
+            __classPrivateFieldGet(this, _TestOpsClient_namedEnvsIdsByEnv, "f").set(env.externalId, {
+                ...env,
+                name: namesById.get(env.externalId) ?? env.externalId,
+            });
+        });
+    }
+    async uploadGlobalAttachments(params) {
+        const { attachments, attachmentsResolver, onProgress } = params;
+        if (!__classPrivateFieldGet(this, _TestOpsClient_session, "f")) {
+            throw new Error("Session isn't created! Call createSession first");
+        }
+        if (!__classPrivateFieldGet(this, _TestOpsClient_launch, "f")) {
+            throw new Error("Launch isn't created! Call createLaunch first");
+        }
+        const formData = new FormData();
+        for (const attachmentLink of attachments) {
+            const attachment = await attachmentsResolver(attachmentLink);
+            if (!attachment) {
+                continue;
+            }
+            formData.append("file", attachment.content, {
+                filename: attachment.originalFileName,
+                contentType: attachment.contentType,
+            });
+        }
+        await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/launch/attachment", formData, {
+            onUploadProgress(progressEvent) {
+                const total = progressEvent.total ?? 100;
+                const percent = total > 0 ? Math.min(100, Math.max(0, (progressEvent.loaded / total) * 100)) : 0;
+                onProgress?.(percent, total);
+            },
+            params: { launchId: __classPrivateFieldGet(this, _TestOpsClient_launch, "f").id },
+            headers: formData.getHeaders(),
+        });
+    }
+    async uploadGlobalErrors(errors, onProgress) {
+        if (!__classPrivateFieldGet(this, _TestOpsClient_session, "f")) {
+            throw new Error("Session isn't created! Call createSession first");
+        }
+        if (!__classPrivateFieldGet(this, _TestOpsClient_launch, "f")) {
+            throw new Error("Launch isn't created! Call createLaunch first");
+        }
+        await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/launch/error/bulk", {
+            launchId: __classPrivateFieldGet(this, _TestOpsClient_launch, "f").id,
+            items: errors,
+        }, {
+            onUploadProgress(progressEvent) {
+                const total = progressEvent.total ?? 100;
+                const percent = total > 0 ? Math.min(100, Math.max(0, (progressEvent.loaded / total) * 100)) : 0;
+                onProgress?.(percent, total);
+            },
+        });
+    }
     async uploadTestResults(params) {
         if (!__classPrivateFieldGet(this, _TestOpsClient_session, "f")) {
             throw new Error("Session isn't created! Call createSession first");
         }
-        const { trs, attachmentsResolver, fixturesResolver, onProgress } = params;
-        const trsChunks = chunk(trs, 100);
+        const { trs, environments, attachmentsResolver, fixturesResolver, onProgress } = params;
+        const trsChunks = chunk(trs, CHUNK_SIZE);
         const uploadLimitFn = pLimit(__classPrivateFieldGet(this, _TestOpsClient_uploadLimit, "f"));
-        await Promise.all(trsChunks.map(async (trsChunk) => {
-            const { data } = await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/upload/test-result", {
-                testSessionId: __classPrivateFieldGet(this, _TestOpsClient_session, "f").id,
-                results: trsChunk.map((tr) => ({
-                    ...tr,
-                    uuid: tr.id,
-                })),
-            }, {
-                headers: {
-                    "Authorization": `Bearer ${__classPrivateFieldGet(this, _TestOpsClient_oauthToken, "f")}`,
-                    "Content-Type": "application/json",
-                },
-            });
-            const trsTestOpsIdsByUuid = data.results.reduce((acc, { id, uuid }) => ({ ...acc, [uuid]: id }), {});
-            await Promise.all(trsChunk.map((tr) => uploadLimitFn(async () => {
-                const trTestOpsId = trsTestOpsIdsByUuid[tr.id];
-                const attachments = await attachmentsResolver(tr);
-                const fixtures = await fixturesResolver(tr);
-                if (attachments.length > 0) {
-                    const attachmentsChunks = chunk(attachments, 100);
-                    await Promise.all(attachmentsChunks.map(async (attachmentsChunk) => {
-                        const formData = new FormData();
-                        attachmentsChunk.forEach((attachment) => {
-                            formData.append("file", attachment.content, {
-                                filename: attachment.originalFileName,
-                                contentType: attachment.contentType,
-                            });
-                        });
-                        await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post(`/api/upload/test-result/${trTestOpsId}/attachment`, formData, {
-                            headers: {
-                                Authorization: `Bearer ${__classPrivateFieldGet(this, _TestOpsClient_oauthToken, "f")}`,
-                                ...formData.getHeaders(),
-                            },
+        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,
                         });
-                    }));
+                    }
                 }
-                if (fixtures.length > 0) {
-                    await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post(`/api/upload/test-result/${trTestOpsId}/test-fixture-result`, {
-                        fixtures,
-                    }, {
-                        headers: {
-                            Authorization: `Bearer ${__classPrivateFieldGet(this, _TestOpsClient_oauthToken, "f")}`,
-                        },
-                    });
+                if (chunkEnvs.size > 0) {
+                    await this.createNamedEnvs(Array.from(chunkEnvs.values()));
                 }
-                onProgress?.();
-            })));
-        }));
+                const reportIdsToTestOpsIds = await __classPrivateFieldGet(this, _TestOpsClient_instances, "m", _TestOpsClient_postTestResultsChunk).call(this, trsChunk);
+                await __classPrivateFieldGet(this, _TestOpsClient_instances, "m", _TestOpsClient_uploadChunkAttachmentsAndFixtures).call(this, trsChunk, reportIdsToTestOpsIds, attachmentsResolver, fixturesResolver, uploadLimitFn, onProgress);
+                uploadedTrs.push(...trsChunk);
+            }
+            __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");
+            }
+        }
+        return uploadedTrs;
+    }
+    async uploadQualityGateResults(results, onProgress) {
+        if (!__classPrivateFieldGet(this, _TestOpsClient_session, "f")) {
+            throw new Error("Session isn't created! Call createSession first");
+        }
+        if (!__classPrivateFieldGet(this, _TestOpsClient_launch, "f")) {
+            throw new Error("Launch isn't created! Call createLaunch first");
+        }
+        const items = results.map((result) => {
+            const item = {
+                name: result.rule,
+                message: result.message,
+            };
+            const namedEnvId = !!result.environment && this.getNamedEnvFor(result.environment)?.id;
+            if (typeof namedEnvId === "number") {
+                item.namedEnvId = namedEnvId;
+            }
+            return item;
+        });
+        await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/launch/quality-gate/bulk", {
+            launchId: __classPrivateFieldGet(this, _TestOpsClient_launch, "f").id,
+            items,
+        }, {
+            onUploadProgress(progressEvent) {
+                const total = progressEvent.total ?? 100;
+                const percent = total > 0 ? Math.min(100, Math.max(0, (progressEvent.loaded / total) * 100)) : 0;
+                onProgress?.(percent, total);
+            },
+        });
     }
 }
-_TestOpsClient_accessToken = new WeakMap(), _TestOpsClient_projectId = new WeakMap(), _TestOpsClient_oauthToken = new WeakMap(), _TestOpsClient_client = new WeakMap(), _TestOpsClient_launch = new WeakMap(), _TestOpsClient_session = new WeakMap(), _TestOpsClient_uploadInProgress = new WeakMap(), _TestOpsClient_uploadLimit = new WeakMap();
+_TestOpsClient_logger = new WeakMap(), _TestOpsClient_accessToken = new WeakMap(), _TestOpsClient_projectId = new WeakMap(), _TestOpsClient_oauthToken = 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) {
+    const { data } = await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/upload/test-result", {
+        testSessionId: __classPrivateFieldGet(this, _TestOpsClient_session, "f").id,
+        results: trsChunk.map((testResult) => {
+            const extendedTestResult = {
+                ...testResult,
+                uuid: testResult.id,
+            };
+            const namedEnvironment = !!testResult.environment && this.getNamedEnvFor(testResult.environment);
+            if (namedEnvironment) {
+                extendedTestResult.namedEnv = { id: namedEnvironment.id };
+            }
+            if (typeof extendedTestResult.category?.externalId === "string" ||
+                typeof extendedTestResult.category?.externalId === "number") {
+                const category = extendedTestResult.category;
+                extendedTestResult.category = {
+                    externalId: category.externalId,
+                };
+                if (category.grouping && category.grouping.length > 0) {
+                    extendedTestResult.category.grouping = category.grouping;
+                }
+            }
+            const error = extendedTestResult.error;
+            if (typeof error?.message === "string") {
+                extendedTestResult.message = error.message;
+            }
+            if (typeof error?.trace === "string") {
+                extendedTestResult.trace = error.trace;
+            }
+            return extendedTestResult;
+        }),
+    }, { headers: { "Content-Type": "application/json" } });
+    const reportIdsToTestOpsIds = {};
+    for (const { id, uuid } of data.results ?? []) {
+        reportIdsToTestOpsIds[uuid] = id;
+    }
+    return reportIdsToTestOpsIds;
+}, _TestOpsClient_uploadChunkAttachmentsAndFixtures = async function _TestOpsClient_uploadChunkAttachmentsAndFixtures(trsChunk, reportIdsToTestOpsIds, attachmentsResolver, fixturesResolver, uploadLimitFn, onProgress) {
+    await Promise.all(trsChunk.map((tr) => uploadLimitFn(async () => {
+        const testOpsId = reportIdsToTestOpsIds[tr.id];
+        const attachments = await attachmentsResolver(tr);
+        const fixtures = await fixturesResolver(tr);
+        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?.();
+    })));
+}, _TestOpsClient_uploadAttachmentsForResult = async function _TestOpsClient_uploadAttachmentsForResult(testOpsResultId, attachments) {
+    if (attachments.length === 0) {
+        return;
+    }
+    const attachmentsChunks = chunk(attachments, 100);
+    for (const attachmentsChunk of attachmentsChunks) {
+        const formData = new FormData();
+        for (const att of attachmentsChunk) {
+            formData.append("file", att.content, {
+                filename: att.originalFileName,
+                contentType: att.contentType,
+            });
+        }
+        try {
+            await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post(`/api/upload/test-result/${testOpsResultId}/attachment`, 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_logger, "f").inspect(formData);
+        }
+    }
+}, _TestOpsClient_uploadFixturesForResult = async function _TestOpsClient_uploadFixturesForResult(testOpsResultId, fixtures) {
+    if (fixtures.length === 0)
+        return;
+    await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post(`/api/upload/test-result/${testOpsResultId}/test-fixture-result`, {
+        fixtures,
+    });
+};

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export type { TestopsPluginOptions as TestopsUploaderPluginOptions } from "./model.js";
-export { TestopsPlugin as default } from "./plugin.js";
+export type { TestOpsPluginOptions as TestOpsUploaderPluginOptions } from "./model.js";
+export { TestOpsPlugin as default } from "./plugin.js";

package/dist/index.js

@@ -1 +1 @@
-export { TestopsPlugin as default } from "./plugin.js";
+export { TestOpsPlugin as default } from "./plugin.js";

package/dist/logger.d.ts

@@ -0,0 +1,24 @@
+import ProgressBar from "progress";
+type JSONMessage = Record<string, unknown> | Array<unknown>;
+export declare class Logger {
+    #private;
+    readonly name: string;
+    constructor(name: string);
+    progressBarCounter(message: string, total: number): ProgressBar | {
+        tick: () => void;
+        update: () => void;
+        terminate: () => void;
+    };
+    progressBar(message: string): ProgressBar | {
+        update: () => void;
+        terminate: () => void;
+    };
+    verbose(message: string | JSONMessage): void;
+    debug(message: string | JSONMessage): void;
+    newLine(): void;
+    info(message: string | JSONMessage): void;
+    warn(message: string | JSONMessage): void;
+    error(message: string | JSONMessage): void;
+    inspect(value: unknown): void;
+}
+export {};