@allurereport/plugin-testops 3.3.0 → 3.4.0

package/dist/plugin.js

@@ -9,155 +9,383 @@ 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_ci, _TestopsPlugin_client, _TestopsPlugin_launchName, _TestopsPlugin_launchTags, _TestopsPlugin_uploadedTestResultsIds, _TestopsPlugin_upload, _TestopsPlugin_startUpload, _TestopsPlugin_stopUpload;
+var _TestOpsPlugin_instances, _TestOpsPlugin_logger, _TestOpsPlugin_ci, _TestOpsPlugin_client, _TestOpsPlugin_enabled, _TestOpsPlugin_launchName, _TestOpsPlugin_launchTags, _TestOpsPlugin_uploadedTestResultsIds, _TestOpsPlugin_autocloseLaunch, _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 } from "@allurereport/ci";
 import { getWorstStatus } from "@allurereport/core-api";
-import { createPluginSummary, } from "@allurereport/plugin-api";
-import { env } from "node:process";
-import ProgressBar from "progress";
+import { createPluginSummary } from "@allurereport/plugin-api";
+import { uniqBy, stubTrue } from "lodash-es";
+import { bold } from "yoctocolors";
 import { TestOpsClient } from "./client.js";
-import { resolvePluginOptions, unwrapStepsAttachments } from "./utils.js";
-export class TestopsPlugin {
+import { Logger } from "./logger.js";
+import { toUploadCategory } from "./uploadCategory.js";
+import { attachmentsResolverFactory, fixturesResolverFactory, resolvePluginOptions, unwrapStepsAttachments, } from "./utils.js";
+const categoryDisplayName = (cat) => cat.name ?? cat.grouping?.[0]?.name ?? cat.grouping?.[0]?.value ?? cat.grouping?.[0]?.key ?? cat.externalId;
+export class TestOpsPlugin {
     constructor(options) {
-        _TestopsPlugin_instances.add(this);
+        _TestOpsPlugin_instances.add(this);
         this.options = options;
-        _TestopsPlugin_ci.set(this, void 0);
-        _TestopsPlugin_client.set(this, void 0);
-        _TestopsPlugin_launchName.set(this, "");
-        _TestopsPlugin_launchTags.set(this, []);
-        _TestopsPlugin_uploadedTestResultsIds.set(this, []);
-        const { accessToken, endpoint, projectId, launchName, launchTags } = resolvePluginOptions(options);
-        __classPrivateFieldSet(this, _TestopsPlugin_ci, detect(), "f");
+        _TestOpsPlugin_logger.set(this, new Logger("TestOpsPlugin"));
+        _TestOpsPlugin_ci.set(this, void 0);
+        _TestOpsPlugin_client.set(this, void 0);
+        _TestOpsPlugin_enabled.set(this, false);
+        _TestOpsPlugin_launchName.set(this, "");
+        _TestOpsPlugin_launchTags.set(this, []);
+        _TestOpsPlugin_uploadedTestResultsIds.set(this, new Set());
+        _TestOpsPlugin_autocloseLaunch.set(this, void 0);
+        const { accessToken, endpoint, projectId, launchName, launchTags, autocloseLaunch = true, } = resolvePluginOptions(options);
+        __classPrivateFieldSet(this, _TestOpsPlugin_ci, detect(), "f");
         if ([accessToken, endpoint, projectId].every(Boolean)) {
-            __classPrivateFieldSet(this, _TestopsPlugin_client, new TestOpsClient({
+            __classPrivateFieldSet(this, _TestOpsPlugin_enabled, true, "f");
+            __classPrivateFieldSet(this, _TestOpsPlugin_client, new TestOpsClient({
                 baseUrl: endpoint,
                 accessToken,
                 projectId,
             }), "f");
-            __classPrivateFieldSet(this, _TestopsPlugin_launchName, launchName, "f");
-            __classPrivateFieldSet(this, _TestopsPlugin_launchTags, launchTags, "f");
+            __classPrivateFieldSet(this, _TestOpsPlugin_launchName, launchName, "f");
+            __classPrivateFieldSet(this, _TestOpsPlugin_launchTags, launchTags, "f");
         }
+        __classPrivateFieldSet(this, _TestOpsPlugin_autocloseLaunch, autocloseLaunch, "f");
         if (!accessToken) {
-            console.warn("TestOps access token is missing. Please provide a valid access token in the plugin options.");
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").warn(`Allure TestOps ${bold("access token")} is missing. Please provide a valid access token in the plugin options.`);
         }
         if (!endpoint) {
-            console.warn("TestOps endpoint is missing. Please provide a valid endpoint in the plugin options.");
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").warn(`Allure TestOps ${bold("endpoint")} is missing. Please provide a valid endpoint in the plugin options.`);
         }
         if (!projectId) {
-            console.warn("TestOps project ID is missing. Please provide a valid project ID in the plugin options.");
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").warn(`Allure TestOps ${bold("project ID")} is missing. Please provide a valid project ID in the plugin options.`);
         }
     }
     get ciMode() {
-        return __classPrivateFieldGet(this, _TestopsPlugin_ci, "f") && __classPrivateFieldGet(this, _TestopsPlugin_ci, "f").type !== "local";
+        return __classPrivateFieldGet(this, _TestOpsPlugin_ci, "f") && __classPrivateFieldGet(this, _TestOpsPlugin_ci, "f").type !== "local";
     }
-    async start(_context, store) {
-        if (!__classPrivateFieldGet(this, _TestopsPlugin_client, "f")) {
+    async start(context, store) {
+        if (!__classPrivateFieldGet(this, _TestOpsPlugin_enabled, "f")) {
             return;
         }
-        await __classPrivateFieldGet(this, _TestopsPlugin_instances, "m", _TestopsPlugin_startUpload).call(this);
-        await __classPrivateFieldGet(this, _TestopsPlugin_instances, "m", _TestopsPlugin_upload).call(this, store, { issueNewToken: false });
-        console.info(`TestOps launch has been created: ${__classPrivateFieldGet(this, _TestopsPlugin_client, "f").launchUrl}`);
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("Starting upload…");
+        await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_startUpload).call(this);
+        await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_upload).call(this, store, { issueNewToken: false, context, stage: "start" });
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info(`Allure TestOps Launch: ${__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").launchUrl}`);
     }
-    async update(_context, store) {
-        if (!__classPrivateFieldGet(this, _TestopsPlugin_client, "f")) {
+    async update(context, store) {
+        if (!__classPrivateFieldGet(this, _TestOpsPlugin_enabled, "f")) {
             return;
         }
-        await __classPrivateFieldGet(this, _TestopsPlugin_instances, "m", _TestopsPlugin_upload).call(this, store);
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("Updating (uploading new results)…");
+        await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_upload).call(this, store, { context, stage: "update" });
     }
-    async done(_context, store) {
-        if (!__classPrivateFieldGet(this, _TestopsPlugin_client, "f")) {
+    async done(context, store) {
+        if (!__classPrivateFieldGet(this, _TestOpsPlugin_enabled, "f")) {
             return;
         }
-        const allTrs = (await store.allTestResults()).filter((tr) => this.options.filter ? this.options.filter(tr) : true);
+        const allTrs = await store.allTestResults({
+            filter: this.options.filter,
+            includeHidden: false,
+        });
         const worstStatus = getWorstStatus(allTrs.map(({ status }) => status));
-        await __classPrivateFieldGet(this, _TestopsPlugin_instances, "m", _TestopsPlugin_upload).call(this, store);
-        await __classPrivateFieldGet(this, _TestopsPlugin_instances, "m", _TestopsPlugin_stopUpload).call(this, worstStatus || "unknown");
+        __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");
+        const launchId = __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").launchId;
+        if (typeof launchId !== "number") {
+            return;
+        }
+        if (!__classPrivateFieldGet(this, _TestOpsPlugin_autocloseLaunch, "f")) {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info(`Upload finished. Allure TestOps Launch: ${__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").launchUrl}`);
+            return;
+        }
+        try {
+            await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").closeLaunch(launchId);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug(`Failed to close launch: ${err.message}`);
+            }
+            else {
+                __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").debug("Failed to close launch");
+            }
+        }
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info(`Upload finished. Allure TestOps Launch: ${__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").launchUrl}`);
     }
     async info(context, store) {
-        if (!__classPrivateFieldGet(this, _TestopsPlugin_client, "f")?.launchUrl) {
+        if (!__classPrivateFieldGet(this, _TestOpsPlugin_enabled, "f")) {
             return undefined;
         }
-        return {
-            ...(await createPluginSummary({
-                name: __classPrivateFieldGet(this, _TestopsPlugin_launchName, "f"),
-                plugin: "TestOps",
-                meta: {
-                    reportId: context.reportUuid,
-                },
-                filter: this.options.filter,
-                history: context.history,
-                ci: context.ci,
-                store,
-            })),
-            remoteHref: __classPrivateFieldGet(this, _TestopsPlugin_client, "f").launchUrl,
-        };
+        if (!__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").launchUrl) {
+            return undefined;
+        }
+        const summary = await createPluginSummary({
+            name: __classPrivateFieldGet(this, _TestOpsPlugin_launchName, "f"),
+            plugin: "TestOps",
+            meta: {
+                reportId: context.reportUuid,
+            },
+            filter: this.options.filter,
+            history: context.history,
+            ci: context.ci,
+            store,
+        });
+        summary.remoteHref = __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").launchUrl;
+        return summary;
     }
 }
-_TestopsPlugin_ci = new WeakMap(), _TestopsPlugin_client = new WeakMap(), _TestopsPlugin_launchName = new WeakMap(), _TestopsPlugin_launchTags = new WeakMap(), _TestopsPlugin_uploadedTestResultsIds = new WeakMap(), _TestopsPlugin_instances = new WeakSet(), _TestopsPlugin_upload = async function _TestopsPlugin_upload(store, options) {
-    const { issueNewToken = true } = options ?? {};
-    const allTrs = await store.allTestResults();
-    const trsToUpload = allTrs.filter((tr) => {
-        const uploaded = __classPrivateFieldGet(this, _TestopsPlugin_uploadedTestResultsIds, "f").includes(tr.id);
-        if (this.options.filter) {
-            return this.options.filter(tr) && !uploaded;
-        }
-        return !uploaded;
+_TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestOpsPlugin_client = new WeakMap(), _TestOpsPlugin_enabled = new WeakMap(), _TestOpsPlugin_launchName = new WeakMap(), _TestOpsPlugin_launchTags = new WeakMap(), _TestOpsPlugin_uploadedTestResultsIds = new WeakMap(), _TestOpsPlugin_autocloseLaunch = 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");
+    try {
+        progressBar.update(0);
+        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadQualityGateResults(uniqueResults, (percent, total) => {
+            progressBar.update(percent / total);
+        });
+        progressBar.update(1);
+        progressBar.terminate();
+    }
+    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);
+        }
+        else if (error instanceof Error) {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to upload quality gate results: ${error.message}`);
+        }
+        else {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error("Failed to upload quality gate results");
+        }
+    }
+}, _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");
+    try {
+        progressBar.update(0);
+        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadGlobalErrors(results, (percent, total) => {
+            progressBar.update(percent / total);
+        });
+        progressBar.update(1);
+        progressBar.terminate();
+    }
+    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);
+        }
+        else if (error instanceof Error) {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to upload global errors: ${error.message}`);
+        }
+        else {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error("Failed to upload global errors");
+        }
+    }
+}, _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");
+    try {
+        progressBar.update(0);
+        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadGlobalAttachments({
+            attachments,
+            attachmentsResolver: async (attachmentLink) => {
+                const content = await store.attachmentContentById(attachmentLink.id);
+                const body = await content?.readContent(async (stream) => stream);
+                const attachmentName = attachmentLink.name || attachmentLink.originalFileName;
+                if (attachmentName === undefined || body === undefined) {
+                    return undefined;
+                }
+                return {
+                    originalFileName: attachmentName,
+                    contentType: attachmentLink.contentType ?? "application/octet-stream",
+                    content: body,
+                };
+            },
+            onProgress: (percent, total) => {
+                progressBar.update(percent / total);
+            },
+        });
+        progressBar.update(1);
+        progressBar.terminate();
+    }
+    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);
+        }
+        else if (error instanceof Error) {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`Failed to upload global attachments: ${error.message}`);
+        }
+        else {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error("Failed to upload global attachments");
+        }
+    }
+}, _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 uploadedCount = uploadedTrs.length;
+    trsProgressBar.update(uploadedCount / totalCount);
+    trsProgressBar.terminate();
+    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"}`);
+}, _TestOpsPlugin_upload = async function _TestOpsPlugin_upload(store, options = {}) {
+    const { issueNewToken = true, context, stage } = options;
+    const trsToUpload = await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_trsToUpload).call(this, store);
     if (trsToUpload.length === 0) {
+        if (stage == "update") {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info("No new test results to upload");
+        }
+        if (stage === "done") {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info("No test results to upload");
+        }
         return;
     }
-    const allTrsWithAttachments = trsToUpload.map((tr) => {
-        return {
-            ...tr,
-            steps: unwrapStepsAttachments(tr.steps),
-        };
-    });
     if (issueNewToken) {
-        await __classPrivateFieldGet(this, _TestopsPlugin_client, "f").issueOauthToken();
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("Issuing new OAuth token");
+        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").issueOauthToken();
     }
-    const progressBar = new ProgressBar("Uploading test results [:bar] :current/:total", {
-        total: allTrsWithAttachments.length,
-        width: 20,
-    });
-    progressBar.render();
-    await __classPrivateFieldGet(this, _TestopsPlugin_client, "f").createSession(env);
-    await __classPrivateFieldGet(this, _TestopsPlugin_client, "f").uploadTestResults({
-        trs: allTrsWithAttachments,
-        onProgress: () => progressBar.tick(),
-        attachmentsResolver: async (tr) => {
-            const attachments = await store.attachmentsByTrId(tr.id);
-            return await Promise.all(attachments.map(async (attachment) => {
-                const content = await store.attachmentContentById(attachment.id);
-                return {
-                    originalFileName: attachment.originalFileName,
-                    contentType: attachment.contentType,
-                    content: await content?.readContent(async (s) => s),
-                };
-            }));
-        },
-        fixturesResolver: async (tr) => {
-            const fxts = await store.fixturesByTrId(tr.id);
-            return fxts.map((fxt) => ({
-                ...fxt,
-                type: fxt.type.toUpperCase(),
-                steps: unwrapStepsAttachments(fxt.steps),
-            }));
+    await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createSession(env);
+    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);
+    const environments = await store.allEnvironmentIdentities();
+    const contextCategories = context?.categories ?? [];
+    const trsEnrichedWithCategories = await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_enrichWithCategories).call(this, store, trsToUpload, contextCategories);
+    await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_syncLaunchCategories).call(this, trsEnrichedWithCategories, contextCategories);
+    await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_uploadTestResults).call(this, store, trsEnrichedWithCategories, environments);
+}, _TestOpsPlugin_trsToUpload = async function _TestOpsPlugin_trsToUpload(store) {
+    const filter = this.options.filter ?? stubTrue;
+    const filteredTrs = await store.allTestResults({
+        filter: (tr) => {
+            const uploaded = __classPrivateFieldGet(this, _TestOpsPlugin_uploadedTestResultsIds, "f").has(tr.id);
+            if (uploaded) {
+                return false;
+            }
+            return filter(tr);
         },
+        includeHidden: false,
     });
-    __classPrivateFieldGet(this, _TestopsPlugin_uploadedTestResultsIds, "f").push(...allTrsWithAttachments.map((tr) => tr.id));
-}, _TestopsPlugin_startUpload = async function _TestopsPlugin_startUpload() {
-    if (!__classPrivateFieldGet(this, _TestopsPlugin_client, "f")) {
+    return filteredTrs;
+}, _TestOpsPlugin_enrichWithCategories = async function _TestOpsPlugin_enrichWithCategories(store, trs, contextCategories) {
+    return Promise.all(trs.map(async (tr) => {
+        const environmentId = await store.environmentIdByTrId(tr.id);
+        const base = {
+            ...tr,
+            ...(environmentId ? { environment: environmentId } : {}),
+            steps: unwrapStepsAttachments(tr.steps),
+        };
+        const category = toUploadCategory(base, contextCategories ?? []);
+        if (category) {
+            base.category = category;
+        }
+        return base;
+    }));
+}, _TestOpsPlugin_syncLaunchCategories = async function _TestOpsPlugin_syncLaunchCategories(trs, contextCategories) {
+    const categoryNamesByExternalId = __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_collectCategoryNamesByExternalId).call(this, trs);
+    if (categoryNamesByExternalId.size === 0) {
         return;
     }
-    await __classPrivateFieldGet(this, _TestopsPlugin_client, "f").issueOauthToken();
-    await __classPrivateFieldGet(this, _TestopsPlugin_client, "f").createLaunch(__classPrivateFieldGet(this, _TestopsPlugin_launchName, "f"), __classPrivateFieldGet(this, _TestopsPlugin_launchTags, "f"));
+    const bulkItems = [];
+    const seenExternalIds = new Set();
+    for (const tr of trs) {
+        const cat = tr.category;
+        if (!cat?.externalId)
+            continue;
+        if (seenExternalIds.has(cat.externalId))
+            continue;
+        seenExternalIds.add(cat.externalId);
+        bulkItems.push({
+            externalId: cat.externalId,
+            name: categoryNamesByExternalId.get(cat.externalId) ?? categoryDisplayName(cat),
+            hide: cat.hide,
+            expand: cat.expand,
+        });
+    }
+    const rankByExternalId = new Map();
+    for (const c of contextCategories) {
+        if (!rankByExternalId.has(c.id)) {
+            rankByExternalId.set(c.id, c.index);
+        }
+        if (!rankByExternalId.has(c.name)) {
+            rankByExternalId.set(c.name, c.index);
+        }
+    }
+    const ranked = bulkItems.map((item, i) => ({
+        item,
+        i,
+        rank: rankByExternalId.get(item.externalId),
+    }));
+    ranked.sort((a, b) => {
+        const ar = a.rank ?? Number.POSITIVE_INFINITY;
+        const br = b.rank ?? Number.POSITIVE_INFINITY;
+        if (ar !== br)
+            return ar - br;
+        return a.i - b.i;
+    });
+    const orderedBulkItems = ranked.map((r) => r.item);
+    const launchId = __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").launchId;
+    try {
+        const created = await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createLaunchCategoriesBulk(launchId, orderedBulkItems);
+        const categoryIdByExternalId = new Map(created.map((r) => [r.externalId, r.id]));
+        __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_assignCreatedCategoryIds).call(this, trs, categoryIdByExternalId);
+    }
+    catch {
+    }
+}, _TestOpsPlugin_collectCategoryNamesByExternalId = function _TestOpsPlugin_collectCategoryNamesByExternalId(trs) {
+    const map = new Map();
+    for (const tr of trs) {
+        const cat = tr.category;
+        if (cat?.externalId) {
+            map.set(cat.externalId, categoryDisplayName(cat));
+        }
+    }
+    return map;
+}, _TestOpsPlugin_assignCreatedCategoryIds = function _TestOpsPlugin_assignCreatedCategoryIds(trs, idByExternalId) {
+    for (const tr of trs) {
+        const cat = tr.category;
+        if (!cat?.externalId) {
+            continue;
+        }
+        const id = idByExternalId.get(cat.externalId);
+        if (typeof id === "number") {
+            tr.category = { ...cat, id };
+        }
+    }
+}, _TestOpsPlugin_startUpload = async function _TestOpsPlugin_startUpload() {
+    await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").issueOauthToken();
+    await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createLaunch(__classPrivateFieldGet(this, _TestOpsPlugin_launchName, "f"), __classPrivateFieldGet(this, _TestOpsPlugin_launchTags, "f"));
     if (!this.ciMode) {
         return;
     }
-    await __classPrivateFieldGet(this, _TestopsPlugin_client, "f").startUpload(__classPrivateFieldGet(this, _TestopsPlugin_ci, "f"));
-}, _TestopsPlugin_stopUpload = async function _TestopsPlugin_stopUpload(status) {
-    if (!this.ciMode || !__classPrivateFieldGet(this, _TestopsPlugin_client, "f")) {
+    await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").startUpload(__classPrivateFieldGet(this, _TestOpsPlugin_ci, "f"));
+}, _TestOpsPlugin_stopUpload = async function _TestOpsPlugin_stopUpload(status) {
+    if (!this.ciMode) {
         return;
     }
-    await __classPrivateFieldGet(this, _TestopsPlugin_client, "f").stopUpload(__classPrivateFieldGet(this, _TestopsPlugin_ci, "f"), status);
+    await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").stopUpload(__classPrivateFieldGet(this, _TestOpsPlugin_ci, "f"), status);
 };

package/dist/uploadCategory.d.ts

@@ -0,0 +1,3 @@
+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/uploadCategory.js

@@ -0,0 +1,20 @@
+import { buildUploadCategoryGrouping, toUploadCategoryFromContext } from "./utils/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/categories.d.ts

@@ -0,0 +1,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"];

package/dist/utils/categories.js

@@ -0,0 +1,82 @@
+import { EMPTY_VALUE, extractErrorMatchingData, findLastByLabelName, matchCategory } from "@allurereport/core-api";
+const formatGroupName = (key, value) => `${key}: ${value === EMPTY_VALUE ? `No ${key}` : value}`;
+const groupValue = (selector, tr) => {
+    const labels = tr.labels ?? [];
+    if (selector === "flaky") {
+        const value = tr.flaky ? "true" : "false";
+        return { key: "flaky", value, name: formatGroupName("flaky", value) };
+    }
+    if (selector === "transition") {
+        const value = tr.transition ?? EMPTY_VALUE;
+        return { key: "transition", value, name: formatGroupName("transition", value) };
+    }
+    if (selector === "status") {
+        const value = tr.status ?? "unknown";
+        return { key: "status", value, name: formatGroupName("status", value) };
+    }
+    if (selector === "environment") {
+        const value = tr.environment?.trim() ? tr.environment : EMPTY_VALUE;
+        return { key: "environment", value, name: formatGroupName("environment", value) };
+    }
+    if (selector === "owner") {
+        const value = findLastByLabelName(labels, "owner") ?? EMPTY_VALUE;
+        return { key: "owner", value, name: formatGroupName("owner", value) };
+    }
+    if (selector === "severity") {
+        const value = findLastByLabelName(labels, "severity") ?? "normal";
+        return { key: "severity", value, name: formatGroupName("severity", value) };
+    }
+    if (selector === "layer") {
+        const value = findLastByLabelName(labels, "layer") ?? EMPTY_VALUE;
+        return { key: "layer", value, name: formatGroupName("layer", value) };
+    }
+    const labelName = selector.label;
+    const labelValue = findLastByLabelName(labels, labelName) ?? EMPTY_VALUE;
+    return { key: labelName, value: labelValue, name: formatGroupName(labelName, labelValue) };
+};
+const buildGrouping = (tr, category) => {
+    const grouping = category.groupBy?.map((selector) => groupValue(selector, tr)) ?? [];
+    if (category.groupByMessage) {
+        const messageValue = tr.error?.message?.trim() ? tr.error.message : EMPTY_VALUE;
+        grouping.push({
+            key: "message",
+            value: messageValue,
+            name: formatGroupName("message", messageValue),
+        });
+    }
+    if (category.groupEnvironments) {
+        const historyValue = tr.historyId ?? tr.id ?? EMPTY_VALUE;
+        const historyName = tr.name?.trim() ? tr.name : historyValue;
+        grouping.push({
+            key: "historyId",
+            value: historyValue,
+            name: historyName,
+        });
+    }
+    if (category.groupEnvironments && !category.groupBy?.some((selector) => selector === "environment")) {
+        const environmentValue = tr.environment?.trim() ? tr.environment : EMPTY_VALUE;
+        grouping.push({
+            key: "environment",
+            value: environmentValue,
+            name: formatGroupName("environment", environmentValue),
+        });
+    }
+    return grouping.length > 0 ? grouping : undefined;
+};
+export const toUploadCategoryFromContext = (tr, categories) => {
+    if (!categories.length) {
+        return undefined;
+    }
+    const matched = matchCategory(categories, extractErrorMatchingData(tr));
+    if (!matched) {
+        return undefined;
+    }
+    return {
+        externalId: matched.id,
+        name: matched.name,
+        grouping: buildGrouping(tr, matched),
+        hide: matched.hide,
+        expand: matched.expand,
+    };
+};
+export const buildUploadCategoryGrouping = (tr, category) => buildGrouping(tr, category);

package/dist/utils.d.ts

@@ -1,4 +1,7 @@
 import type { TestStepResult } from "@allurereport/core-api";
-import type { TestopsPluginOptions } from "./model.js";
+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 const resolvePluginOptions: (options: TestOpsPluginOptions) => Omit<TestOpsPluginOptions, "filter">;
+export declare function attachmentsResolverFactory(store: AllureStore): AttachmentsResolver;
+export declare function fixturesResolverFactory(store: AllureStore): FixtureResolver;