@allurereport/plugin-testops 3.1.0

package/README.md

@@ -0,0 +1,72 @@
+# Allure TestOps Plugin
+
+[<img src="https://allurereport.org/public/img/allure-report.svg" height="85px" alt="Allure Report logo" align="right" />](https://allurereport.org "Allure Report")
+
+- Learn more about Allure Report at https://allurereport.org
+- 📚 [Documentation](https://allurereport.org/docs/) – discover official documentation for Allure Report
+- ❓ [Questions and Support](https://github.com/orgs/allure-framework/discussions/categories/questions-support) – get help from the team and community
+- 📢 [Official announcements](https://github.com/orgs/allure-framework/discussions/categories/announcements) – be in touch with the latest updates
+- 💬 [General Discussion ](https://github.com/orgs/allure-framework/discussions/categories/general-discussion) – engage in casual conversations, share insights and ideas with the community
+
+---
+
+## Overview
+
+The plugin creates a new launch in Allure TestOps with all the tests data from the current report.
+
+## Install
+
+Use your favorite package manager to install the package:
+
+```shell
+npm add @allurereport/plugin-testops
+yarn add @allurereport/plugin-testops
+pnpm add @allurereport/plugin-testops
+```
+
+Then, add the plugin to the Allure configuration file:
+
+```diff
+import { defineConfig } from "allure";
+
+export default defineConfig({
+  name: "Allure Report",
+  output: "./allure-report",
+  historyPath: "./history.jsonl",
+  plugins: {
++    testops: {
++      options: {
++        launchName: "Hello, TestOps!",
++        launchTags: ["tag1", "tag2"],
++        accessToken: "your_testops_access_token",
++        endpoint: "https://your-testops-instance.com",
++        projectId: "your_testops_project_id",
++      },
++    },
+  },
+});
+```
+
+## Options
+
+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`             |
+
+### Using options from environment variables
+
+The plugin automatically reads the following environment variables and uses them if not provided in the configuration (the configuration has a higher priority):
+
+| Environment Variable | Configuration option |
+|----------------------|----------------------|
+| `ALLURE_TOKEN` | `accessToken` |
+| `ALLURE_PROJECT_ID` | `projectId` |
+| `ALLURE_ENDPOINT` | `endpoint` |
+| `ALLURE_LAUNCH_NAME` | `launchName` |
+| `ALLURE_LAUNCH_TAGS` | `launchTags` |

package/dist/client.d.ts

@@ -0,0 +1,20 @@
+import type { CiDescriptor, TestResult, TestStatus } from "@allurereport/core-api";
+export declare class TestOpsClient {
+    #private;
+    constructor(params: {
+        baseUrl: string;
+        projectId: string;
+        accessToken: string;
+    });
+    get launchUrl(): string | undefined;
+    issueOauthToken(): Promise<void>;
+    startUpload(ci: CiDescriptor): Promise<void>;
+    stopUpload(ci: CiDescriptor, status: TestStatus): Promise<void>;
+    createLaunch(launchName: string, launchTags: string[]): Promise<void>;
+    createSession(): Promise<void>;
+    uploadTestResults(params: {
+        trs: TestResult[];
+        attachmentsResolver: (tr: TestResult) => Promise<any>;
+        fixturesResolver: (tr: TestResult) => Promise<any>;
+    }): Promise<void>;
+}

package/dist/client.js

@@ -0,0 +1,179 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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;
+import axios from "axios";
+import FormData from "form-data";
+import chunk from "lodash.chunk";
+export class TestOpsClient {
+    constructor(params) {
+        _TestOpsClient_accessToken.set(this, void 0);
+        _TestOpsClient_projectId.set(this, void 0);
+        _TestOpsClient_oauthToken.set(this, "");
+        _TestOpsClient_client.set(this, void 0);
+        _TestOpsClient_launch.set(this, void 0);
+        _TestOpsClient_session.set(this, void 0);
+        _TestOpsClient_uploadInProgress.set(this, false);
+        if (!params.accessToken) {
+            throw new Error("accessToken is required");
+        }
+        if (!params.projectId) {
+            throw new Error("projectId is required");
+        }
+        if (!params.baseUrl) {
+            throw new Error("baseUrl is required");
+        }
+        __classPrivateFieldSet(this, _TestOpsClient_accessToken, params.accessToken, "f");
+        __classPrivateFieldSet(this, _TestOpsClient_projectId, params.projectId, "f");
+        __classPrivateFieldSet(this, _TestOpsClient_client, axios.create({
+            baseURL: params.baseUrl,
+            validateStatus: (status) => status >= 200 && status < 400,
+        }), "f");
+    }
+    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();
+    }
+    async issueOauthToken() {
+        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");
+    }
+    async startUpload(ci) {
+        if (!__classPrivateFieldGet(this, _TestOpsClient_launch, "f")) {
+            throw new Error("Launch isn't created! Call createLaunch first");
+        }
+        await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/upload/start", {
+            projectId: __classPrivateFieldGet(this, _TestOpsClient_projectId, "f"),
+            ci: {
+                name: ci.type,
+            },
+            job: {
+                name: ci.jobUid,
+                uid: ci.jobUid,
+            },
+            jobRun: {
+                uid: ci.jobRunUid,
+            },
+            launch: {
+                id: __classPrivateFieldGet(this, _TestOpsClient_launch, "f").id,
+            },
+        }, {
+            headers: {
+                Authorization: `Bearer ${__classPrivateFieldGet(this, _TestOpsClient_oauthToken, "f")}`,
+            },
+        });
+        __classPrivateFieldSet(this, _TestOpsClient_uploadInProgress, true, "f");
+    }
+    async stopUpload(ci, status) {
+        if (!__classPrivateFieldGet(this, _TestOpsClient_uploadInProgress, "f")) {
+            throw new Error("Upload isn't started! Call startUpload first");
+        }
+        await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/upload/stop", {
+            jobRunUid: ci.jobRunUid,
+            jobUid: ci.jobUid,
+            projectId: __classPrivateFieldGet(this, _TestOpsClient_projectId, "f"),
+            status,
+        }, {
+            headers: {
+                Authorization: `Bearer ${__classPrivateFieldGet(this, _TestOpsClient_oauthToken, "f")}`,
+            },
+        });
+        __classPrivateFieldSet(this, _TestOpsClient_uploadInProgress, false, "f");
+    }
+    async createLaunch(launchName, launchTags) {
+        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");
+    }
+    async createSession() {
+        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/rs/upload/session?manual=true", {
+            launchId: __classPrivateFieldGet(this, _TestOpsClient_launch, "f").id,
+        }, {
+            headers: {
+                Authorization: `Bearer ${__classPrivateFieldGet(this, _TestOpsClient_oauthToken, "f")}`,
+            },
+        });
+        __classPrivateFieldSet(this, _TestOpsClient_session, data, "f");
+    }
+    async uploadTestResults(params) {
+        if (!__classPrivateFieldGet(this, _TestOpsClient_session, "f")) {
+            throw new Error("Session isn't created! Call createSession first");
+        }
+        const { trs, attachmentsResolver, fixturesResolver } = params;
+        const trsChunks = chunk(trs, 100);
+        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(async (tr) => {
+                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(),
+                            },
+                        });
+                    }));
+                }
+                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")}`,
+                        },
+                    });
+                }
+            }));
+        }));
+    }
+}
+_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();

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export type { TestopsUploaderPluginOptions } from "./model.js";
+export { TestopsUploaderPlugin as default } from "./plugin.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { TestopsUploaderPlugin as default } from "./plugin.js";

package/dist/model.d.ts

@@ -0,0 +1,34 @@
+import type { AttachmentLink, TestResult } from "@allurereport/core-api";
+export type TestopsUploaderOptions = {
+    endpoint: string;
+    accessToken: string;
+    projectId: string;
+    launchName: string;
+    launchTags: string[];
+    filter?: (testResult: TestResult) => boolean;
+};
+export type TemplateManifest = Record<string, string>;
+export type TestopsUploaderPluginOptions = TestopsUploaderOptions;
+export type TestOpsSession = {
+    id: number;
+    jobId: number;
+    jobRunId: number;
+    launchId: number;
+    projectId: number;
+};
+export type TestOpsLaunch = {
+    id: number;
+    name: string;
+    closed: boolean;
+    external: boolean;
+    autoclose: boolean;
+    projectId: number;
+    tags: string[];
+    links: [];
+    issues: [];
+    createdDate: number;
+    lastModifiedDate: number;
+};
+export type TestResultWithAttachments = TestResult & {
+    attachments: AttachmentLink[];
+};

package/dist/model.js

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

package/dist/plugin.d.ts

@@ -0,0 +1,12 @@
+import { type AllureStore, type Plugin, type PluginContext, type PluginSummary } from "@allurereport/plugin-api";
+import type { TestopsUploaderPluginOptions } from "./model.js";
+export declare class TestopsUploaderPlugin implements Plugin {
+    #private;
+    readonly options: TestopsUploaderPluginOptions;
+    constructor(options: TestopsUploaderPluginOptions);
+    get ciMode(): boolean | undefined;
+    start(_context: PluginContext, store: AllureStore): Promise<void>;
+    update(_context: PluginContext, store: AllureStore): Promise<void>;
+    done(_context: PluginContext, store: AllureStore): Promise<void>;
+    info(context: PluginContext, store: AllureStore): Promise<PluginSummary | undefined>;
+}

package/dist/plugin.js

@@ -0,0 +1,163 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _TestopsUploaderPlugin_instances, _TestopsUploaderPlugin_ci, _TestopsUploaderPlugin_client, _TestopsUploaderPlugin_launchName, _TestopsUploaderPlugin_launchTags, _TestopsUploaderPlugin_uploadedTestResultsIds, _TestopsUploaderPlugin_upload, _TestopsUploaderPlugin_startUpload, _TestopsUploaderPlugin_stopUpload;
+import { detect } from "@allurereport/ci";
+import { getWorstStatus } from "@allurereport/core-api";
+import { convertToSummaryTestResult, } from "@allurereport/plugin-api";
+import { TestOpsClient } from "./client.js";
+import { resolvePluginOptions, unwrapStepsAttachments } from "./utils.js";
+export class TestopsUploaderPlugin {
+    constructor(options) {
+        _TestopsUploaderPlugin_instances.add(this);
+        this.options = options;
+        _TestopsUploaderPlugin_ci.set(this, void 0);
+        _TestopsUploaderPlugin_client.set(this, void 0);
+        _TestopsUploaderPlugin_launchName.set(this, "");
+        _TestopsUploaderPlugin_launchTags.set(this, []);
+        _TestopsUploaderPlugin_uploadedTestResultsIds.set(this, []);
+        const { accessToken, endpoint, projectId, launchName, launchTags } = resolvePluginOptions(options);
+        __classPrivateFieldSet(this, _TestopsUploaderPlugin_ci, detect(), "f");
+        if ([accessToken, endpoint, projectId].every(Boolean)) {
+            __classPrivateFieldSet(this, _TestopsUploaderPlugin_client, new TestOpsClient({
+                baseUrl: endpoint,
+                accessToken,
+                projectId,
+            }), "f");
+            __classPrivateFieldSet(this, _TestopsUploaderPlugin_launchName, launchName, "f");
+            __classPrivateFieldSet(this, _TestopsUploaderPlugin_launchTags, launchTags, "f");
+        }
+        if (!accessToken) {
+            console.warn("TestOps 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.");
+        }
+        if (!projectId) {
+            console.warn("TestOps project ID is missing. Please provide a valid project ID in the plugin options.");
+        }
+    }
+    get ciMode() {
+        return __classPrivateFieldGet(this, _TestopsUploaderPlugin_ci, "f") && __classPrivateFieldGet(this, _TestopsUploaderPlugin_ci, "f").type !== "local";
+    }
+    async start(_context, store) {
+        if (!__classPrivateFieldGet(this, _TestopsUploaderPlugin_client, "f")) {
+            return;
+        }
+        await __classPrivateFieldGet(this, _TestopsUploaderPlugin_instances, "m", _TestopsUploaderPlugin_startUpload).call(this);
+        await __classPrivateFieldGet(this, _TestopsUploaderPlugin_instances, "m", _TestopsUploaderPlugin_upload).call(this, store, { issueNewToken: false });
+        console.info(`TestOps launch has been created: ${__classPrivateFieldGet(this, _TestopsUploaderPlugin_client, "f").launchUrl}`);
+    }
+    async update(_context, store) {
+        if (!__classPrivateFieldGet(this, _TestopsUploaderPlugin_client, "f")) {
+            return;
+        }
+        await __classPrivateFieldGet(this, _TestopsUploaderPlugin_instances, "m", _TestopsUploaderPlugin_upload).call(this, store);
+    }
+    async done(_context, store) {
+        if (!__classPrivateFieldGet(this, _TestopsUploaderPlugin_client, "f")) {
+            return;
+        }
+        const allTrs = (await store.allTestResults()).filter((tr) => this.options.filter ? this.options.filter(tr) : true);
+        const worstStatus = getWorstStatus(allTrs.map(({ status }) => status));
+        await __classPrivateFieldGet(this, _TestopsUploaderPlugin_instances, "m", _TestopsUploaderPlugin_upload).call(this, store);
+        await __classPrivateFieldGet(this, _TestopsUploaderPlugin_instances, "m", _TestopsUploaderPlugin_stopUpload).call(this, worstStatus || "unknown");
+    }
+    async info(context, store) {
+        if (!__classPrivateFieldGet(this, _TestopsUploaderPlugin_client, "f")?.launchUrl) {
+            return undefined;
+        }
+        const allTrs = (await store.allTestResults()).filter((tr) => this.options.filter ? this.options.filter(tr) : true);
+        const newTrs = await store.allNewTestResults();
+        const retryTrs = allTrs.filter((tr) => !!tr?.retries?.length);
+        const flakyTrs = allTrs.filter((tr) => !!tr?.flaky);
+        const duration = allTrs.reduce((acc, { duration: trDuration = 0 }) => acc + trDuration, 0);
+        const worstStatus = getWorstStatus(allTrs.map(({ status }) => status));
+        const createdAt = allTrs.reduce((acc, { stop }) => Math.max(acc, stop || 0), 0);
+        return {
+            name: __classPrivateFieldGet(this, _TestopsUploaderPlugin_launchName, "f"),
+            remoteHref: __classPrivateFieldGet(this, _TestopsUploaderPlugin_client, "f").launchUrl,
+            stats: await store.testsStatistic(this.options.filter),
+            status: worstStatus ?? "passed",
+            duration,
+            createdAt,
+            plugin: "Awesome",
+            newTests: newTrs.map(convertToSummaryTestResult),
+            flakyTests: flakyTrs.map(convertToSummaryTestResult),
+            retryTests: retryTrs.map(convertToSummaryTestResult),
+            meta: {
+                reportId: context.reportUuid,
+            },
+        };
+    }
+}
+_TestopsUploaderPlugin_ci = new WeakMap(), _TestopsUploaderPlugin_client = new WeakMap(), _TestopsUploaderPlugin_launchName = new WeakMap(), _TestopsUploaderPlugin_launchTags = new WeakMap(), _TestopsUploaderPlugin_uploadedTestResultsIds = new WeakMap(), _TestopsUploaderPlugin_instances = new WeakSet(), _TestopsUploaderPlugin_upload = async function _TestopsUploaderPlugin_upload(store, options) {
+    const { issueNewToken = true } = options ?? {};
+    const allTrs = await store.allTestResults();
+    const trsToUpload = allTrs.filter((tr) => {
+        const uploaded = __classPrivateFieldGet(this, _TestopsUploaderPlugin_uploadedTestResultsIds, "f").includes(tr.id);
+        if (this.options.filter) {
+            return this.options.filter(tr) && !uploaded;
+        }
+        return !uploaded;
+    });
+    if (trsToUpload.length === 0) {
+        return;
+    }
+    const allTrsWithAttachments = trsToUpload.map((tr) => {
+        return {
+            ...tr,
+            steps: unwrapStepsAttachments(tr.steps),
+        };
+    });
+    if (issueNewToken) {
+        await __classPrivateFieldGet(this, _TestopsUploaderPlugin_client, "f").issueOauthToken();
+    }
+    await __classPrivateFieldGet(this, _TestopsUploaderPlugin_client, "f").createSession();
+    await __classPrivateFieldGet(this, _TestopsUploaderPlugin_client, "f").uploadTestResults({
+        trs: allTrsWithAttachments,
+        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),
+            }));
+        },
+    });
+    __classPrivateFieldGet(this, _TestopsUploaderPlugin_uploadedTestResultsIds, "f").push(...allTrsWithAttachments.map((tr) => tr.id));
+}, _TestopsUploaderPlugin_startUpload = async function _TestopsUploaderPlugin_startUpload() {
+    if (!__classPrivateFieldGet(this, _TestopsUploaderPlugin_client, "f")) {
+        return;
+    }
+    await __classPrivateFieldGet(this, _TestopsUploaderPlugin_client, "f").issueOauthToken();
+    await __classPrivateFieldGet(this, _TestopsUploaderPlugin_client, "f").createLaunch(__classPrivateFieldGet(this, _TestopsUploaderPlugin_launchName, "f"), __classPrivateFieldGet(this, _TestopsUploaderPlugin_launchTags, "f"));
+    if (!this.ciMode) {
+        return;
+    }
+    await __classPrivateFieldGet(this, _TestopsUploaderPlugin_client, "f").startUpload(__classPrivateFieldGet(this, _TestopsUploaderPlugin_ci, "f"));
+}, _TestopsUploaderPlugin_stopUpload = async function _TestopsUploaderPlugin_stopUpload(status) {
+    if (!this.ciMode || !__classPrivateFieldGet(this, _TestopsUploaderPlugin_client, "f")) {
+        return;
+    }
+    await __classPrivateFieldGet(this, _TestopsUploaderPlugin_client, "f").stopUpload(__classPrivateFieldGet(this, _TestopsUploaderPlugin_ci, "f"), status);
+};

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+import type { TestStepResult } from "@allurereport/core-api";
+import type { TestopsUploaderPluginOptions } from "./model.js";
+export declare const unwrapStepsAttachments: (steps: TestStepResult[]) => TestStepResult[];
+export declare const resolvePluginOptions: (options: TestopsUploaderPluginOptions) => Omit<TestopsUploaderPluginOptions, "filter">;

package/dist/utils.js

@@ -0,0 +1,34 @@
+import { env } from "node:process";
+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, } = 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 || "",
+    };
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@allurereport/plugin-testops",
+  "version": "3.1.0",
+  "description": "Allure Plugin TestOps",
+  "keywords": [
+    "allure",
+    "testing",
+    "report",
+    "plugin",
+    "html",
+    "testops",
+    "uploader"
+  ],
+  "repository": "https://github.com/allure-framework/allure3",
+  "license": "Apache-2.0",
+  "author": "Qameta Software",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "./dist"
+  ],
+  "scripts": {
+    "build": "run clean && tsc --project ./tsconfig.json",
+    "clean": "rimraf ./dist",
+    "eslint": "eslint ./src/**/*.{js,jsx,ts,tsx}",
+    "eslint:format": "eslint --fix ./src/**/*.{js,jsx,ts,tsx}",
+    "test": "rimraf ./out && vitest run"
+  },
+  "dependencies": {
+    "@allurereport/ci": "3.1.0",
+    "@allurereport/core-api": "3.1.0",
+    "@allurereport/plugin-api": "3.1.0",
+    "@allurereport/reader-api": "3.1.0",
+    "axios": "^1.13.2",
+    "form-data": "^4.0.5",
+    "lodash.chunk": "^4.2.0"
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2.6.1",
+    "@types/d3-shape": "^3.1.6",
+    "@types/eslint": "^8.56.11",
+    "@types/form-data": "^2.5.2",
+    "@types/lodash.chunk": "^4",
+    "@types/node": "^20.17.9",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "@vitest/runner": "^2.1.9",
+    "@vitest/snapshot": "^2.1.9",
+    "allure-vitest": "^3.3.3",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-jsdoc": "^50.0.0",
+    "eslint-plugin-n": "^17.10.1",
+    "eslint-plugin-no-null": "^1.0.2",
+    "eslint-plugin-prefer-arrow": "^1.2.3",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.9"
+  }
+}