@allurereport/plugin-testops 3.14.3 → 3.15.0

package/dist/client.js

@@ -17,8 +17,10 @@ import { chunk } from "lodash-es";
 import pLimit from "p-limit";
 import { bold } from "yoctocolors";
 import { Logger } from "./logger.js";
+import { toUploadFixturesResultsDto } from "./utils/fixtures.js";
 import { testStatusToLaunchStatus } from "./utils/launches.js";
-import { toUploadFixturesResultsDto, toUploadResultsDto } from "./utils/uploaderDto.js";
+import { normalizeTestStepsResults, toUploadResultsDto } from "./utils/testResults.js";
+import { validateExecutableName } from "./utils/validation.js";
 class TestOpsClientError extends AxiosError {
 }
 const CHUNK_SIZE = 100;
@@ -291,7 +293,11 @@ export class TestOpsClient {
             throw new Error("Session isn't created! Call createSession first");
         }
         const { trs, environments, attachmentsResolver, fixturesResolver, onProgress } = params;
-        const trsChunks = chunk(trs, CHUNK_SIZE);
+        const projectedTrs = trs.map((tr) => ({
+            ...tr,
+            ...(tr.steps ? { steps: normalizeTestStepsResults(tr.steps) } : {}),
+        }));
+        const trsChunks = chunk(projectedTrs, CHUNK_SIZE);
         const uploadLimitFn = pLimit(__classPrivateFieldGet(this, _TestOpsClient_uploadLimit, "f"));
         const uploadedTrs = [];
         const envNamesById = new Map(environments.map(({ id, name }) => [id, name]));
@@ -311,8 +317,8 @@ export class TestOpsClient {
                     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);
-                uploadedTrs.push(...trsChunk);
             }
             __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose("Test results upload completed");
         }
@@ -395,8 +401,16 @@ _TestOpsClient_baseUrl = new WeakMap(), _TestOpsClient_logger = new WeakMap(), _
 }, _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];
+        if (typeof testOpsId !== "number") {
+            return;
+        }
         const attachments = await attachmentsResolver(tr);
-        const fixtures = await fixturesResolver(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?.();

package/dist/logger.d.ts

@@ -1,18 +1,8 @@
-import ProgressBar from "progress";
 type JSONMessage = Record<string, unknown> | Array<unknown>;
 export declare class Logger {
     #private;
     private readonly loggerName;
     constructor(loggerName: 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;

package/dist/logger.js

@@ -13,7 +13,6 @@ var _Logger_instances, _Logger_level, _Logger_prefix, _Logger_isLogLevel, _Logge
 import console from "node:console";
 import { env } from "node:process";
 import { inspect } from "node:util";
-import ProgressBar from "progress";
 import { blue, bold, cyan, dim, gray, red, yellow } from "yoctocolors";
 const logLevelsPriority = {
     silent: Number.MAX_SAFE_INTEGER,
@@ -43,33 +42,6 @@ export class Logger {
         _Logger_prefix.set(this, void 0);
         __classPrivateFieldSet(this, _Logger_prefix, cyan(bold(`[${this.loggerName}]:`)), "f");
     }
-    progressBarCounter(message, total) {
-        if (__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_isSilent).call(this)) {
-            return {
-                tick: () => { },
-                update: () => { },
-                terminate: () => { },
-            };
-        }
-        const progressBar = new ProgressBar(`${__classPrivateFieldGet(this, _Logger_prefix, "f")} ${blue(message)} [:bar] :current/:total`, {
-            total,
-            width: 20,
-        });
-        return progressBar;
-    }
-    progressBar(message) {
-        if (__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_isSilent).call(this)) {
-            return {
-                update: () => { },
-                terminate: () => { },
-            };
-        }
-        const progressBar = new ProgressBar(`${__classPrivateFieldGet(this, _Logger_prefix, "f")} ${blue(message)} [:bar] :percent`, {
-            total: 100,
-            width: 20,
-        });
-        return progressBar;
-    }
     verbose(message) {
         if (!__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_isLogLevel).call(this, "verbose")) {
             return;

package/dist/model.d.ts

@@ -53,7 +53,7 @@ export type UploadLabelDto = {
 };
 export type UploadTestResultBodyStepDto = {
     type: "body";
-    body?: string;
+    body: string;
     bodyJson?: unknown;
     status?: UploadTestStatus;
     start?: number;
@@ -91,7 +91,7 @@ export type UploadTestResultDto = {
     uuid?: string;
     historyId?: string;
     testCaseId?: string;
-    name?: string;
+    name: string;
     fullName?: string;
     description?: string;
     descriptionHtml?: string;
@@ -131,7 +131,7 @@ export type UploadTestFixtureType = "BEFORE" | "AFTER";
 export type UploadTestFixtureResultDto = {
     type?: UploadTestFixtureType;
     uuid?: string;
-    name?: string;
+    name: string;
     start?: number;
     stop?: number;
     duration?: number;

package/dist/plugin.js

@@ -9,9 +9,10 @@ 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 _TestOpsPlugin_instances, _TestOpsPlugin_logger, _TestOpsPlugin_ci, _TestOpsPlugin_client, _TestOpsPlugin_launchName, _TestOpsPlugin_launchTags, _TestOpsPlugin_uploadedTestResultsIds, _TestOpsPlugin_autocloseLaunch, _TestOpsPlugin_gitFlow, _TestOpsPlugin_enabledByConfig, _TestOpsPlugin_uploadQualityGateResults, _TestOpsPlugin_uploadGlobalErrors, _TestOpsPlugin_uploadGlobalAttachments, _TestOpsPlugin_uploadTestResults, _TestOpsPlugin_upload, _TestOpsPlugin_trsToUpload, _TestOpsPlugin_enrichWithCategories, _TestOpsPlugin_syncLaunchCategories, _TestOpsPlugin_collectCategoryNamesByExternalId, _TestOpsPlugin_assignCreatedCategoryIds, _TestOpsPlugin_startUpload, _TestOpsPlugin_stopUpload;
+var _TestOpsPlugin_instances, _TestOpsPlugin_logger, _TestOpsPlugin_ci, _TestOpsPlugin_client, _TestOpsPlugin_launchName, _TestOpsPlugin_launchTags, _TestOpsPlugin_uploadedTestResultsIds, _TestOpsPlugin_autocloseLaunch, _TestOpsPlugin_launchStarted, _TestOpsPlugin_gitFlow, _TestOpsPlugin_enabledByConfig, _TestOpsPlugin_uploadQualityGateResults, _TestOpsPlugin_uploadGlobalErrors, _TestOpsPlugin_uploadGlobalAttachments, _TestOpsPlugin_uploadTestResults, _TestOpsPlugin_upload, _TestOpsPlugin_trsToUpload, _TestOpsPlugin_enrichWithCategories, _TestOpsPlugin_syncLaunchCategories, _TestOpsPlugin_collectCategoryNamesByExternalId, _TestOpsPlugin_assignCreatedCategoryIds, _TestOpsPlugin_startUpload, _TestOpsPlugin_stopUpload;
 import { env } from "node:process";
 import { detect, isLocalCiDescriptor } from "@allurereport/ci";
+import { createProgressLogger } from "@allurereport/cli-commons";
 import { getWorstStatus } from "@allurereport/core-api";
 import { createPluginSummary, } from "@allurereport/plugin-api";
 import { uniqBy, stubTrue } from "lodash-es";
@@ -19,9 +20,11 @@ import { bold } from "yoctocolors";
 import { TestOpsClient } from "./client.js";
 import { LaunchGitFlow, resolveGitFlowOptions } from "./gitFlow/index.js";
 import { Logger } from "./logger.js";
-import { attachmentsResolverFactory, fixturesResolverFactory, resolvePluginOptions, unwrapStepsAttachments, } from "./utils/index.js";
-import { toUploadCategory } from "./utils/uploadCategory.js";
-import { uploadFilenameForLink } from "./utils/uploaderDto.js";
+import { uploadFilenameForLink } from "./utils/attachments.js";
+import { toUploadCategory } from "./utils/categories.js";
+import { resolvePluginOptions } from "./utils/options.js";
+import { attachmentsResolverFactory, fixturesResolverFactory, unwrapStepsAttachments } from "./utils/resolvers.js";
+import { validateExecutableName } from "./utils/validation.js";
 const LAUNCH_PROGRESS_POLL_DELAY_MS = 500;
 const LAUNCH_PROGRESS_ATTEMPTS_LIMIT = 10;
 const categoryDisplayName = (cat) => cat.name ?? cat.grouping?.[0]?.name ?? cat.grouping?.[0]?.value ?? cat.grouping?.[0]?.key ?? cat.externalId;
@@ -36,6 +39,7 @@ export class TestOpsPlugin {
         _TestOpsPlugin_launchTags.set(this, []);
         _TestOpsPlugin_uploadedTestResultsIds.set(this, new Set());
         _TestOpsPlugin_autocloseLaunch.set(this, false);
+        _TestOpsPlugin_launchStarted.set(this, false);
         _TestOpsPlugin_gitFlow.set(this, void 0);
         _TestOpsPlugin_enabledByConfig.set(this, false);
         __classPrivateFieldSet(this, _TestOpsPlugin_enabledByConfig, context.enabled === true, "f");
@@ -103,7 +107,9 @@ export class TestOpsPlugin {
             return;
         }
         __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("Starting upload…");
-        await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_startUpload).call(this);
+        if (!(await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_startUpload).call(this))) {
+            return;
+        }
         await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_upload).call(this, store, { context, stage: "start" });
         __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info(`Allure TestOps Launch: ${__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").launchUrl}`);
     }
@@ -111,6 +117,10 @@ export class TestOpsPlugin {
         if (!this.enabled) {
             return;
         }
+        if (!__classPrivateFieldGet(this, _TestOpsPlugin_launchStarted, "f")) {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("Skipping update: the TestOps launch was never started");
+            return;
+        }
         __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("Updating (uploading new results)…");
         await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_upload).call(this, store, { context, stage: "update" });
     }
@@ -118,6 +128,10 @@ export class TestOpsPlugin {
         if (!this.enabled) {
             return;
         }
+        if (!__classPrivateFieldGet(this, _TestOpsPlugin_launchStarted, "f")) {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("Skipping finalization: the TestOps launch was never started");
+            return;
+        }
         const allTrs = await store.allTestResults({
             filter: this.options.filter,
             includeRetries: false,
@@ -125,7 +139,21 @@ export class TestOpsPlugin {
         const worstStatus = getWorstStatus(allTrs.map(({ status }) => status));
         __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("Finalizing upload…");
         await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_upload).call(this, store, { context, stage: "done" });
-        await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_stopUpload).call(this, worstStatus || "unknown");
+        try {
+            await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_stopUpload).call(this, worstStatus || "unknown");
+        }
+        catch (error) {
+            if (__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").isTestOpsClientError(error)) {
+                __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to stop TestOps upload: ${error.response.data.message}`);
+                __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug(error.response?.data);
+            }
+            else if (error instanceof Error) {
+                __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to stop TestOps upload: ${error.message}`);
+            }
+            else {
+                __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error("Failed to stop TestOps upload");
+            }
+        }
         const launchId = __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").launchId;
         if (typeof launchId !== "number") {
             return;
@@ -181,24 +209,34 @@ export class TestOpsPlugin {
         return summary;
     }
 }
-_TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestOpsPlugin_client = new WeakMap(), _TestOpsPlugin_launchName = new WeakMap(), _TestOpsPlugin_launchTags = new WeakMap(), _TestOpsPlugin_uploadedTestResultsIds = new WeakMap(), _TestOpsPlugin_autocloseLaunch = new WeakMap(), _TestOpsPlugin_gitFlow = new WeakMap(), _TestOpsPlugin_enabledByConfig = new WeakMap(), _TestOpsPlugin_instances = new WeakSet(), _TestOpsPlugin_uploadQualityGateResults = async function _TestOpsPlugin_uploadQualityGateResults(store) {
+_TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestOpsPlugin_client = new WeakMap(), _TestOpsPlugin_launchName = new WeakMap(), _TestOpsPlugin_launchTags = new WeakMap(), _TestOpsPlugin_uploadedTestResultsIds = new WeakMap(), _TestOpsPlugin_autocloseLaunch = new WeakMap(), _TestOpsPlugin_launchStarted = new WeakMap(), _TestOpsPlugin_gitFlow = new WeakMap(), _TestOpsPlugin_enabledByConfig = new WeakMap(), _TestOpsPlugin_instances = new WeakSet(), _TestOpsPlugin_uploadQualityGateResults = async function _TestOpsPlugin_uploadQualityGateResults(store) {
     const results = await store.qualityGateResults();
     const uniqueResults = uniqBy(results.filter(({ success }) => !success), ({ rule, environment }) => `${rule}-${environment}`);
     if (uniqueResults.length === 0) {
         __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("No quality gate results to upload");
         return;
     }
-    const progressBar = __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").progressBar("Uploading quality gate results");
+    const progressLogger = createProgressLogger({
+        total: 1,
+        message: "Uploading quality gate results",
+        unitLabel: "request uploaded",
+        prefix: "[TestOpsPlugin]",
+    });
+    let completed = false;
     try {
-        progressBar.update(0);
-        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadQualityGateResults(uniqueResults, (percent, total) => {
-            progressBar.update(percent / total);
+        progressLogger.log(true);
+        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadQualityGateResults(uniqueResults, (percent) => {
+            if (!completed && percent >= 100) {
+                completed = true;
+                progressLogger.increment();
+            }
         });
-        progressBar.update(1);
-        progressBar.terminate();
+        if (!completed) {
+            progressLogger.increment();
+        }
+        progressLogger.log(true);
     }
     catch (error) {
-        progressBar.terminate();
         if (__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").isTestOpsClientError(error)) {
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to upload quality gate results: ${error.response.data.message}`);
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug(error.response?.data);
@@ -210,23 +248,36 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error("Failed to upload quality gate results");
         }
     }
+    finally {
+        progressLogger.cancel?.();
+    }
 }, _TestOpsPlugin_uploadGlobalErrors = async function _TestOpsPlugin_uploadGlobalErrors(store) {
     const results = await store.allGlobalErrors();
     if (results.length === 0) {
         __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("No global errors to upload");
         return;
     }
-    const progressBar = __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").progressBar("Uploading global errors");
+    const progressLogger = createProgressLogger({
+        total: 1,
+        message: "Uploading global errors",
+        unitLabel: "request uploaded",
+        prefix: "[TestOpsPlugin]",
+    });
+    let completed = false;
     try {
-        progressBar.update(0);
-        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadGlobalErrors(results, (percent, total) => {
-            progressBar.update(percent / total);
+        progressLogger.log(true);
+        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadGlobalErrors(results, (percent) => {
+            if (!completed && percent >= 100) {
+                completed = true;
+                progressLogger.increment();
+            }
         });
-        progressBar.update(1);
-        progressBar.terminate();
+        if (!completed) {
+            progressLogger.increment();
+        }
+        progressLogger.log(true);
     }
     catch (error) {
-        progressBar.terminate();
         if (__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").isTestOpsClientError(error)) {
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to upload global errors: ${error.response.data.message}`);
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug(error.response?.data);
@@ -238,15 +289,24 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error("Failed to upload global errors");
         }
     }
+    finally {
+        progressLogger.cancel?.();
+    }
 }, _TestOpsPlugin_uploadGlobalAttachments = async function _TestOpsPlugin_uploadGlobalAttachments(store) {
     const attachments = await store.allGlobalAttachments();
     if (attachments.length === 0) {
         __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug("No global attachments to upload");
         return;
     }
-    const progressBar = __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").progressBar("Uploading global attachments");
+    const progressLogger = createProgressLogger({
+        total: 1,
+        message: "Uploading global attachments",
+        unitLabel: "request uploaded",
+        prefix: "[TestOpsPlugin]",
+    });
+    let completed = false;
     try {
-        progressBar.update(0);
+        progressLogger.log(true);
         await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadGlobalAttachments({
             attachments,
             attachmentsResolver: async (attachmentLink) => {
@@ -262,15 +322,19 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
                     content: body,
                 };
             },
-            onProgress: (percent, total) => {
-                progressBar.update(percent / total);
+            onProgress: (percent) => {
+                if (!completed && percent >= 100) {
+                    completed = true;
+                    progressLogger.increment();
+                }
             },
         });
-        progressBar.update(1);
-        progressBar.terminate();
+        if (!completed) {
+            progressLogger.increment();
+        }
+        progressLogger.log(true);
     }
     catch (error) {
-        progressBar.terminate();
         if (__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").isTestOpsClientError(error)) {
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to upload global attachments: ${error.response.data.message}`);
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug(error.response?.data);
@@ -282,28 +346,43 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error("Failed to upload global attachments");
         }
     }
+    finally {
+        progressLogger.cancel?.();
+    }
 }, _TestOpsPlugin_uploadTestResults = async function _TestOpsPlugin_uploadTestResults(store, trsToUpload, environments) {
     const totalCount = trsToUpload.length;
     __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info(`Preparing to upload ${bold(totalCount.toString())} ${totalCount > 1 ? "test results" : "test result"}`);
-    const trsProgressBar = __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").progressBarCounter("Uploading test results", totalCount);
-    const uploadedTrs = await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadTestResults({
-        attachmentsResolver: attachmentsResolverFactory(store),
-        fixturesResolver: fixturesResolverFactory(store),
-        environments,
-        trs: trsToUpload,
-        onProgress: () => trsProgressBar.tick(),
-    });
-    uploadedTrs.forEach((tr) => {
-        __classPrivateFieldGet(this, _TestOpsPlugin_uploadedTestResultsIds, "f").add(tr.id);
+    const progressLogger = createProgressLogger({
+        total: totalCount,
+        message: "Uploading test results",
+        unitLabel: totalCount === 1 ? "test result uploaded" : "test results uploaded",
+        prefix: "[TestOpsPlugin]",
     });
-    const uploadedCount = uploadedTrs.length;
-    trsProgressBar.update(uploadedCount / totalCount);
-    trsProgressBar.terminate();
-    if (uploadedCount === 0) {
-        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").warn("No test results were uploaded");
-        return;
+    const logProgress = progressLogger.log;
+    const incrementProgress = progressLogger.increment;
+    try {
+        logProgress(true);
+        const uploadedTrs = await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadTestResults({
+            attachmentsResolver: attachmentsResolverFactory(store),
+            fixturesResolver: fixturesResolverFactory(store),
+            environments,
+            trs: trsToUpload,
+            onProgress: () => incrementProgress(),
+        });
+        logProgress(true);
+        uploadedTrs.forEach((tr) => {
+            __classPrivateFieldGet(this, _TestOpsPlugin_uploadedTestResultsIds, "f").add(tr.id);
+        });
+        const uploadedCount = uploadedTrs.length;
+        if (uploadedCount === 0) {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").warn("No test results were uploaded");
+            return;
+        }
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info(`Uploaded ${uploadedCount} ${uploadedCount > 1 ? "test results" : "test result"}`);
+    }
+    finally {
+        progressLogger.cancel?.();
     }
-    __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info(`Uploaded ${uploadedCount} ${uploadedCount > 1 ? "test results" : "test result"}`);
 }, _TestOpsPlugin_upload = async function _TestOpsPlugin_upload(store, options = {}) {
     const { context, stage } = options;
     const trsToUpload = await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_trsToUpload).call(this, store);
@@ -316,7 +395,22 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
         }
         return;
     }
-    await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createSession(env);
+    try {
+        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createSession(env);
+    }
+    catch (error) {
+        if (__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").isTestOpsClientError(error)) {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to create TestOps session: ${error.response.data.message}`);
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug(error.response?.data);
+        }
+        else if (error instanceof Error) {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to create TestOps session: ${error.message}`);
+        }
+        else {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error("Failed to create TestOps session");
+        }
+        return;
+    }
     await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_uploadGlobalAttachments).call(this, store);
     await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_uploadGlobalErrors).call(this, store);
     await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_uploadQualityGateResults).call(this, store);
@@ -333,7 +427,7 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
             if (uploaded) {
                 return false;
             }
-            return filter(tr);
+            return validateExecutableName(tr.name) && filter(tr);
         },
         includeRetries: false,
     });
@@ -425,8 +519,24 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
     }
 }, _TestOpsPlugin_startUpload = async function _TestOpsPlugin_startUpload() {
     const launchGitContext = __classPrivateFieldGet(this, _TestOpsPlugin_gitFlow, "f").resolve();
-    await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createLaunch(__classPrivateFieldGet(this, _TestOpsPlugin_launchName, "f"), __classPrivateFieldGet(this, _TestOpsPlugin_launchTags, "f"), launchGitContext);
-    await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").startUpload(__classPrivateFieldGet(this, _TestOpsPlugin_ci, "f"));
+    try {
+        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createLaunch(__classPrivateFieldGet(this, _TestOpsPlugin_launchName, "f"), __classPrivateFieldGet(this, _TestOpsPlugin_launchTags, "f"), launchGitContext);
+        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").startUpload(__classPrivateFieldGet(this, _TestOpsPlugin_ci, "f"));
+        __classPrivateFieldSet(this, _TestOpsPlugin_launchStarted, true, "f");
+    }
+    catch (error) {
+        if (__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").isTestOpsClientError(error)) {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to create TestOps launch: ${error.response.data.message}`);
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug(error.response?.data);
+        }
+        else if (error instanceof Error) {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to create TestOps launch: ${error.message}`);
+        }
+        else {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error("Failed to create TestOps launch");
+        }
+    }
+    return __classPrivateFieldGet(this, _TestOpsPlugin_launchStarted, "f");
 }, _TestOpsPlugin_stopUpload = async function _TestOpsPlugin_stopUpload(status) {
     await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").stopUpload(__classPrivateFieldGet(this, _TestOpsPlugin_ci, "f"), status);
 };

package/dist/utils/attachments.d.ts

@@ -0,0 +1,5 @@
+import type { AttachmentLink, TestStepResult } from "@allurereport/core-api";
+import type { UploadAttachmentDto } from "../model.js";
+export declare const uploadFilenameForLink: (link: AttachmentLink) => string | undefined;
+export declare const toUploadAttachmentDto: (link: AttachmentLink) => UploadAttachmentDto;
+export declare const getAttachmentIdsFromTestStepsResults: (steps: TestStepResult[] | undefined) => Set<string>;

package/dist/utils/attachments.js

@@ -0,0 +1,27 @@
+export const uploadFilenameForLink = (link) => {
+    if ("originalFileName" in link && typeof link.originalFileName === "string")
+        return link.originalFileName;
+    return undefined;
+};
+export const toUploadAttachmentDto = (link) => ({
+    name: "name" in link && typeof link.name === "string" ? link.name : undefined,
+    originalFileName: uploadFilenameForLink(link),
+    contentType: "contentType" in link && typeof link.contentType === "string" ? link.contentType : undefined,
+    contentLength: "contentLength" in link && typeof link.contentLength === "number" ? link.contentLength : undefined,
+    optional: "optional" in link && typeof link.optional === "boolean"
+        ? link.optional
+        : undefined,
+});
+export const getAttachmentIdsFromTestStepsResults = (steps) => {
+    const ids = new Set();
+    for (const step of steps ?? []) {
+        if (step.type === "attachment") {
+            ids.add(step.link.id);
+        }
+        else {
+            for (const id of getAttachmentIdsFromTestStepsResults(step.steps))
+                ids.add(id);
+        }
+    }
+    return ids;
+};

package/dist/utils/categories.d.ts

@@ -2,3 +2,4 @@ import type { CategoryDefinition } from "@allurereport/core-api";
 import type { TestResultWithCategories, UploadCategory } from "../model.js";
 export declare const toUploadCategoryFromContext: (tr: TestResultWithCategories, categories: CategoryDefinition[]) => UploadCategory | undefined;
 export declare const buildUploadCategoryGrouping: (tr: TestResultWithCategories, category: CategoryDefinition) => UploadCategory["grouping"];
+export declare const toUploadCategory: (tr: TestResultWithCategories, contextCategories: CategoryDefinition[]) => UploadCategory | undefined;

package/dist/utils/categories.js

@@ -80,3 +80,21 @@ export const toUploadCategoryFromContext = (tr, categories) => {
     };
 };
 export const buildUploadCategoryGrouping = (tr, category) => buildGrouping(tr, category);
+export const toUploadCategory = (tr, contextCategories) => {
+    const c = tr.categories?.[0];
+    if (c?.name) {
+        const externalId = c.id ?? c.name;
+        const groupingFromTestResult = c.grouping?.length ? c.grouping : undefined;
+        const contextCategory = groupingFromTestResult === undefined
+            ? contextCategories.find((category) => category.id === externalId || category.name === c.name)
+            : undefined;
+        return {
+            externalId,
+            name: c.name,
+            grouping: groupingFromTestResult ?? (contextCategory && buildUploadCategoryGrouping(tr, contextCategory)),
+            hide: c.hide,
+            expand: c.expand,
+        };
+    }
+    return toUploadCategoryFromContext(tr, contextCategories);
+};

package/dist/utils/fixtures.d.ts

@@ -0,0 +1,4 @@
+import type { UploadFixturesResultsDto, UploadTestFixtureResultDto } from "../model.js";
+import type { TestOpsFixtureResult } from "../model.js";
+export declare const toUploadFixtureResultDto: (fxt: TestOpsFixtureResult) => UploadTestFixtureResultDto;
+export declare const toUploadFixturesResultsDto: (fixtures: TestOpsFixtureResult[]) => UploadFixturesResultsDto;

package/dist/utils/fixtures.js

@@ -0,0 +1,30 @@
+import { toUploadAttachmentDto } from "./attachments.js";
+const toUploadStepDto = (step) => step.type === "attachment"
+    ? { type: "attachment", attachment: toUploadAttachmentDto(step.link) }
+    : {
+        type: "body",
+        body: step.name,
+        status: step.status,
+        start: step.start,
+        stop: step.stop,
+        duration: step.duration,
+        message: typeof step.message === "string" ? step.message : undefined,
+        trace: typeof step.trace === "string" ? step.trace : undefined,
+        parameters: step.parameters,
+        steps: step.steps?.map(toUploadStepDto),
+    };
+export const toUploadFixtureResultDto = (fxt) => ({
+    type: fxt.type,
+    uuid: fxt.id,
+    name: fxt.name,
+    start: fxt.start,
+    stop: fxt.stop,
+    duration: fxt.duration,
+    status: fxt.status,
+    message: fxt.error?.message,
+    trace: fxt.error?.trace,
+    steps: fxt.steps?.map(toUploadStepDto),
+});
+export const toUploadFixturesResultsDto = (fixtures) => ({
+    fixtures: fixtures.map(toUploadFixtureResultDto),
+});

package/dist/utils/index.d.ts

@@ -1,7 +1,7 @@
-import type { TestStepResult } from "@allurereport/core-api";
-import { AllureStore } from "@allurereport/plugin-api";
-import type { AttachmentsResolver, FixtureResolver, TestOpsPluginOptions } from "../model.js";
-export declare const unwrapStepsAttachments: (steps: TestStepResult[]) => TestStepResult[];
-export declare const resolvePluginOptions: (options: TestOpsPluginOptions) => Omit<TestOpsPluginOptions, "filter">;
-export declare function attachmentsResolverFactory(store: AllureStore): AttachmentsResolver;
-export declare function fixturesResolverFactory(store: AllureStore): FixtureResolver;
+export { toUploadAttachmentDto, uploadFilenameForLink } from "./attachments.js";
+export { toUploadCategory, buildUploadCategoryGrouping, toUploadCategoryFromContext } from "./categories.js";
+export { toUploadFixtureResultDto, toUploadFixturesResultsDto } from "./fixtures.js";
+export { resolvePluginOptions } from "./options.js";
+export { attachmentsResolverFactory, fixturesResolverFactory, unwrapStepsAttachments } from "./resolvers.js";
+export { normalizeTestStepsResults, toUploadResultsDto, toUploadTestResultDto } from "./testResults.js";
+export { validateExecutableName } from "./validation.js";

package/dist/utils/index.js

@@ -1,68 +1,7 @@
-import { env } from "node:process";
-import { uploadFilenameForLink } from "./uploaderDto.js";
-export const unwrapStepsAttachments = (steps) => {
-    return steps.map((step) => {
-        if (step.type === "attachment") {
-            return {
-                ...step,
-                attachment: step.link,
-            };
-        }
-        if (step.steps) {
-            return {
-                ...step,
-                steps: unwrapStepsAttachments(step.steps),
-            };
-        }
-        return step;
-    });
-};
-export const resolvePluginOptions = (options) => {
-    const { ALLURE_TOKEN, ALLURE_ENDPOINT, ALLURE_PROJECT_ID, ALLURE_LAUNCH_TAGS, ALLURE_LAUNCH_NAME } = env;
-    const { accessToken = ALLURE_TOKEN, endpoint = ALLURE_ENDPOINT, projectId = ALLURE_PROJECT_ID, launchTags = ALLURE_LAUNCH_TAGS, launchName = ALLURE_LAUNCH_NAME, autocloseLaunch, } = options;
-    const tags = !launchTags
-        ? []
-        : Array.isArray(launchTags)
-            ? launchTags
-            : launchTags.split(",").map((tag) => tag.trim());
-    return {
-        launchName: launchName || "Allure Report",
-        launchTags: tags,
-        accessToken: accessToken || "",
-        endpoint: endpoint || "",
-        projectId: projectId || "",
-        ...(autocloseLaunch !== undefined ? { autocloseLaunch } : {}),
-    };
-};
-export function attachmentsResolverFactory(store) {
-    const attachmentsResolver = async (tr) => {
-        const attachments = await store.attachmentsByTrId(tr.id);
-        const result = [];
-        await Promise.all(attachments.map(async (attachment) => {
-            const content = await store.attachmentContentById(attachment.id);
-            const body = await content?.readContent(async (s) => s);
-            const filename = uploadFilenameForLink(attachment);
-            if (filename === undefined || body === undefined) {
-                return undefined;
-            }
-            result.push({
-                originalFileName: filename,
-                contentType: attachment.contentType ?? "application/octet-stream",
-                content: body,
-            });
-        }));
-        return result;
-    };
-    return attachmentsResolver;
-}
-export function fixturesResolverFactory(store) {
-    const fixturesResolver = async (tr) => {
-        const fixtures = await store.fixturesByTrId(tr.id);
-        return fixtures.map((fxt) => ({
-            ...fxt,
-            type: fxt.type.toUpperCase(),
-            steps: unwrapStepsAttachments(fxt.steps),
-        }));
-    };
-    return fixturesResolver;
-}
+export { toUploadAttachmentDto, uploadFilenameForLink } from "./attachments.js";
+export { toUploadCategory, buildUploadCategoryGrouping, toUploadCategoryFromContext } from "./categories.js";
+export { toUploadFixtureResultDto, toUploadFixturesResultsDto } from "./fixtures.js";
+export { resolvePluginOptions } from "./options.js";
+export { attachmentsResolverFactory, fixturesResolverFactory, unwrapStepsAttachments } from "./resolvers.js";
+export { normalizeTestStepsResults, toUploadResultsDto, toUploadTestResultDto } from "./testResults.js";
+export { validateExecutableName } from "./validation.js";

package/dist/utils/options.d.ts

@@ -0,0 +1,2 @@
+import type { TestOpsPluginOptions } from "../model.js";
+export declare const resolvePluginOptions: (options: TestOpsPluginOptions) => Omit<TestOpsPluginOptions, "filter">;

package/dist/utils/options.js

@@ -0,0 +1,18 @@
+import { env } from "node:process";
+export const resolvePluginOptions = (options) => {
+    const { ALLURE_TOKEN, ALLURE_ENDPOINT, ALLURE_PROJECT_ID, ALLURE_LAUNCH_TAGS, ALLURE_LAUNCH_NAME } = env;
+    const { accessToken = ALLURE_TOKEN, endpoint = ALLURE_ENDPOINT, projectId = ALLURE_PROJECT_ID, launchTags = ALLURE_LAUNCH_TAGS, launchName = ALLURE_LAUNCH_NAME, autocloseLaunch, } = options;
+    const tags = !launchTags
+        ? []
+        : Array.isArray(launchTags)
+            ? launchTags
+            : launchTags.split(",").map((tag) => tag.trim());
+    return {
+        launchName: launchName || "Allure Report",
+        launchTags: tags,
+        accessToken: accessToken || "",
+        endpoint: endpoint || "",
+        projectId: projectId || "",
+        ...(autocloseLaunch !== undefined ? { autocloseLaunch } : {}),
+    };
+};

package/dist/utils/resolvers.d.ts

@@ -0,0 +1,6 @@
+import type { TestStepResult } from "@allurereport/core-api";
+import { AllureStore } from "@allurereport/plugin-api";
+import type { AttachmentsResolver, FixtureResolver } from "../model.js";
+export declare const unwrapStepsAttachments: (steps: TestStepResult[]) => TestStepResult[];
+export declare function attachmentsResolverFactory(store: AllureStore): AttachmentsResolver;
+export declare function fixturesResolverFactory(store: AllureStore): FixtureResolver;

package/dist/utils/resolvers.js

@@ -0,0 +1,58 @@
+import { getAttachmentIdsFromTestStepsResults, uploadFilenameForLink } from "./attachments.js";
+import { normalizeTestStepsResults } from "./testResults.js";
+import { validateExecutableName } from "./validation.js";
+export const unwrapStepsAttachments = (steps) => steps.map((step) => step.type === "attachment"
+    ? { ...step, attachment: step.link }
+    : step.steps
+        ? { ...step, steps: unwrapStepsAttachments(step.steps) }
+        : step);
+export function attachmentsResolverFactory(store) {
+    const attachmentsResolver = async (tr) => {
+        const attachments = await store.attachmentsByTrId(tr.id);
+        const fixtures = await store.fixturesByTrId(tr.id);
+        const allowedAttachmentIds = getAttachmentIdsFromTestStepsResults(normalizeTestStepsResults(tr.steps));
+        for (const attachment of tr.attachments ?? []) {
+            allowedAttachmentIds.add(attachment.id);
+        }
+        for (const fixture of fixtures) {
+            if (!validateExecutableName(fixture.name)) {
+                continue;
+            }
+            for (const id of getAttachmentIdsFromTestStepsResults(normalizeTestStepsResults(fixture.steps))) {
+                allowedAttachmentIds.add(id);
+            }
+        }
+        const result = [];
+        const attachmentsById = new Map(attachments.map((attachment) => [attachment.id, attachment]));
+        await Promise.all([...allowedAttachmentIds].map(async (id) => {
+            const attachment = (await store.attachmentById(id)) ?? attachmentsById.get(id);
+            if (!attachment) {
+                return undefined;
+            }
+            const content = await store.attachmentContentById(attachment.id);
+            const body = await content?.readContent(async (s) => s);
+            const filename = uploadFilenameForLink(attachment);
+            if (filename === undefined || body === undefined) {
+                return undefined;
+            }
+            result.push({
+                originalFileName: filename,
+                contentType: attachment.contentType ?? "application/octet-stream",
+                content: body,
+            });
+        }));
+        return result;
+    };
+    return attachmentsResolver;
+}
+export function fixturesResolverFactory(store) {
+    const fixturesResolver = async (tr) => {
+        const fixtures = await store.fixturesByTrId(tr.id);
+        return fixtures.map((fxt) => ({
+            ...fxt,
+            type: fxt.type.toUpperCase(),
+            steps: unwrapStepsAttachments(normalizeTestStepsResults(fxt.steps) ?? []),
+        }));
+    };
+    return fixturesResolver;
+}

package/dist/utils/testResults.d.ts

@@ -0,0 +1,6 @@
+import type { TestStepResult } from "@allurereport/core-api";
+import type { UploadResultsDto, UploadTestResultDto } from "../model.js";
+import type { TestOpsPluginTestResult } from "../model.js";
+export declare const normalizeTestStepsResults: (steps: TestStepResult[] | undefined) => TestStepResult[] | undefined;
+export declare const toUploadTestResultDto: (tr: TestOpsPluginTestResult) => UploadTestResultDto;
+export declare const toUploadResultsDto: (testSessionId: number, trs: TestOpsPluginTestResult[]) => UploadResultsDto;

package/dist/utils/{uploaderDto.js → testResults.js}

@@ -1,27 +1,23 @@
-const isObject = (v) => typeof v === "object" && v !== null;
-const hasString = (obj, key) => typeof obj[key] === "string";
-export const uploadFilenameForLink = (link) => {
-    if ("originalFileName" in link && typeof link.originalFileName === "string")
-        return link.originalFileName;
-    return undefined;
-};
-export const toUploadAttachmentDto = (link) => {
-    return {
-        name: "name" in link && typeof link.name === "string" ? link.name : undefined,
-        originalFileName: uploadFilenameForLink(link),
-        contentType: "contentType" in link && typeof link.contentType === "string" ? link.contentType : undefined,
-        contentLength: "contentLength" in link && typeof link.contentLength === "number" ? link.contentLength : undefined,
-        optional: "optional" in link && typeof link.optional === "boolean"
-            ? link.optional
-            : undefined,
-    };
+import { toUploadAttachmentDto } from "./attachments.js";
+import { validateExecutableName } from "./validation.js";
+export const normalizeTestStepsResults = (steps) => {
+    if (!steps) {
+        return undefined;
+    }
+    const projected = [];
+    for (const step of steps) {
+        if (step.type === "attachment") {
+            projected.push(step);
+        }
+        else if (validateExecutableName(step.name)) {
+            projected.push({ ...step, ...(step.steps ? { steps: normalizeTestStepsResults(step.steps) } : {}) });
+        }
+    }
+    return projected;
 };
 const toUploadStepDto = (step) => {
     if (step.type === "attachment") {
-        return {
-            type: "attachment",
-            attachment: toUploadAttachmentDto(step.link),
-        };
+        return { type: "attachment", attachment: toUploadAttachmentDto(step.link) };
     }
     return {
         type: "body",
@@ -36,6 +32,8 @@ const toUploadStepDto = (step) => {
         steps: step.steps?.map(toUploadStepDto),
     };
 };
+const isObject = (v) => typeof v === "object" && v !== null;
+const hasString = (obj, key) => typeof obj[key] === "string";
 const normalizeCategory = (category) => {
     if (!category)
         return undefined;
@@ -46,8 +44,9 @@ const normalizeCategory = (category) => {
         : typeof externalIdUnknown === "number"
             ? String(externalIdUnknown)
             : undefined;
-    if (!externalId)
+    if (!externalId) {
         return undefined;
+    }
     const grouping = Array.isArray(groupingUnknown)
         ? groupingUnknown
             .filter(isObject)
@@ -58,25 +57,18 @@ const normalizeCategory = (category) => {
         }))
             .filter((g) => g.key || g.value || g.name)
         : undefined;
-    return {
-        externalId,
-        ...(grouping && grouping.length > 0 ? { grouping } : {}),
-    };
+    return { externalId, ...(grouping && grouping.length > 0 ? { grouping } : {}) };
 };
 const optionalArray = (v, isItem) => {
-    if (!Array.isArray(v))
+    if (!Array.isArray(v)) {
         return undefined;
-    const out = [];
-    for (const item of v) {
-        if (isItem(item))
-            out.push(item);
     }
-    return out;
+    return v.filter(isItem);
 };
 const isAttachmentLink = (v) => isObject(v) && hasString(v, "id");
 export const toUploadTestResultDto = (tr) => {
-    const attachmentsUnknown = tr.attachments;
-    const attachments = optionalArray(attachmentsUnknown, isAttachmentLink)?.map(toUploadAttachmentDto);
+    const attachments = optionalArray(tr.attachments, isAttachmentLink)?.map(toUploadAttachmentDto);
+    const category = normalizeCategory(tr.category);
     return {
         uuid: tr.id,
         historyId: tr.historyId,
@@ -98,7 +90,7 @@ export const toUploadTestResultDto = (tr) => {
         hostId: tr.hostId,
         threadId: tr.threadId,
         environment: tr.environment,
-        ...(normalizeCategory(tr.category) ? { category: normalizeCategory(tr.category) } : {}),
+        ...(category ? { category } : {}),
         ...(typeof tr.namedEnv?.id === "number" ? { namedEnv: { id: tr.namedEnv.id } } : {}),
         steps: tr.steps?.map(toUploadStepDto),
         ...(attachments ? { attachments } : {}),
@@ -107,26 +99,7 @@ export const toUploadTestResultDto = (tr) => {
         labels: tr.labels,
     };
 };
-export const toUploadResultsDto = (testSessionId, trs) => {
-    return {
-        testSessionId,
-        results: trs.map(toUploadTestResultDto),
-    };
-};
-export const toUploadFixtureResultDto = (fxt) => {
-    return {
-        type: fxt.type,
-        uuid: fxt.id,
-        name: fxt.name,
-        start: fxt.start,
-        stop: fxt.stop,
-        duration: fxt.duration,
-        status: fxt.status,
-        message: fxt.error?.message,
-        trace: fxt.error?.trace,
-        steps: fxt.steps?.map(toUploadStepDto),
-    };
-};
-export const toUploadFixturesResultsDto = (fixtures) => {
-    return { fixtures: fixtures.map(toUploadFixtureResultDto) };
-};
+export const toUploadResultsDto = (testSessionId, trs) => ({
+    testSessionId,
+    results: trs.map(toUploadTestResultDto),
+});

package/dist/utils/validation.d.ts

@@ -0,0 +1 @@
+export declare const validateExecutableName: (name: unknown) => name is string;

package/dist/utils/validation.js

@@ -0,0 +1,22 @@
+export const validateExecutableName = (name) => {
+    if (typeof name !== "string" || name.length === 0 || name.trim().length === 0) {
+        return false;
+    }
+    for (let index = 0; index < name.length; index += 1) {
+        const code = name.charCodeAt(index);
+        if (code <= 0x1f || (code >= 0x7f && code <= 0x9f) || code === 0xfffd) {
+            return false;
+        }
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const nextCode = name.charCodeAt(index + 1);
+            if (nextCode < 0xdc00 || nextCode > 0xdfff || Number.isNaN(nextCode)) {
+                return false;
+            }
+            index += 1;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            return false;
+        }
+    }
+    return true;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-testops",
-  "version": "3.14.3",
+  "version": "3.15.0",
   "description": "Allure Plugin TestOps",
   "keywords": [
     "allure",
@@ -32,24 +32,23 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/ci": "3.14.3",
-    "@allurereport/core-api": "3.14.3",
-    "@allurereport/git": "3.14.3",
-    "@allurereport/plugin-api": "3.14.3",
-    "@allurereport/reader-api": "3.14.3",
-    "@allurereport/service": "3.14.3",
+    "@allurereport/ci": "3.15.0",
+    "@allurereport/cli-commons": "3.15.0",
+    "@allurereport/core-api": "3.15.0",
+    "@allurereport/git": "3.15.0",
+    "@allurereport/plugin-api": "3.15.0",
+    "@allurereport/reader-api": "3.15.0",
+    "@allurereport/service": "3.15.0",
     "axios": "^1.18.1",
     "form-data": "^4.0.6",
     "lodash-es": "^4.18.1",
     "p-limit": "^7.3.0",
-    "progress": "^2.0.3",
     "yoctocolors": "^2"
   },
   "devDependencies": {
     "@types/d3-shape": "^3.1.8",
     "@types/lodash-es": "^4",
     "@types/node": "^20",
-    "@types/progress": "^2",
     "@vitest/runner": "^2",
     "@vitest/snapshot": "^2.1.9",
     "allure-js-commons": "^3",

package/dist/utils/uploadCategory.d.ts

@@ -1,3 +0,0 @@
-import type { CategoryDefinition } from "@allurereport/core-api";
-import type { TestResultWithCategories, UploadCategory } from "../model.js";
-export declare const toUploadCategory: (tr: TestResultWithCategories, contextCategories: CategoryDefinition[]) => UploadCategory | undefined;

package/dist/utils/uploadCategory.js

@@ -1,20 +0,0 @@
-import { buildUploadCategoryGrouping, toUploadCategoryFromContext } from "./categories.js";
-export const toUploadCategory = (tr, contextCategories) => {
-    const c = tr.categories?.[0];
-    if (c?.name) {
-        const externalId = c.id ?? c.name;
-        const { hide, expand } = c || {};
-        const groupingFromTestResult = c.grouping?.length ? c.grouping : undefined;
-        const contextCategory = groupingFromTestResult === undefined
-            ? contextCategories.find((category) => category.id === externalId || category.name === c.name)
-            : undefined;
-        return {
-            externalId,
-            name: c.name,
-            grouping: groupingFromTestResult ?? (contextCategory && buildUploadCategoryGrouping(tr, contextCategory)),
-            hide,
-            expand,
-        };
-    }
-    return toUploadCategoryFromContext(tr, contextCategories);
-};

package/dist/utils/uploaderDto.d.ts

@@ -1,9 +0,0 @@
-import type { AttachmentLink } from "@allurereport/core-api";
-import type { UploadAttachmentDto, UploadFixturesResultsDto, UploadResultsDto, UploadTestFixtureResultDto, UploadTestResultDto } from "../model.js";
-import type { TestOpsFixtureResult, TestOpsPluginTestResult } from "../model.js";
-export declare const uploadFilenameForLink: (link: AttachmentLink) => string | undefined;
-export declare const toUploadAttachmentDto: (link: AttachmentLink) => UploadAttachmentDto;
-export declare const toUploadTestResultDto: (tr: TestOpsPluginTestResult) => UploadTestResultDto;
-export declare const toUploadResultsDto: (testSessionId: number, trs: TestOpsPluginTestResult[]) => UploadResultsDto;
-export declare const toUploadFixtureResultDto: (fxt: TestOpsFixtureResult) => UploadTestFixtureResultDto;
-export declare const toUploadFixturesResultsDto: (fixtures: TestOpsFixtureResult[]) => UploadFixturesResultsDto;