@allurereport/plugin-testops 3.16.0 → 3.16.1

package/dist/utils/ciOverrides.js

@@ -0,0 +1,20 @@
+import { env } from "node:process";
+const OVERRIDABLE_FIELDS = [
+    ["jobUid", "ALLURE_JOB_UID"],
+    ["jobUrl", "ALLURE_JOB_URL"],
+    ["jobName", "ALLURE_JOB_NAME"],
+    ["jobRunUid", "ALLURE_JOB_RUN_UID"],
+    ["jobRunUrl", "ALLURE_JOB_RUN_URL"],
+    ["jobRunName", "ALLURE_JOB_RUN_NAME"],
+    ["jobRunBranch", "ALLURE_JOB_RUN_BRANCH"],
+];
+export const applyCiOverrides = (ci) => {
+    const overrides = {};
+    for (const [field, envVar] of OVERRIDABLE_FIELDS) {
+        const value = env[envVar];
+        if (value) {
+            overrides[field] = value;
+        }
+    }
+    return Object.keys(overrides).length > 0 ? { ...ci, ...overrides } : ci;
+};

package/dist/utils/httpRetry.d.ts

@@ -0,0 +1,4 @@
+import type { AttachmentForUpload } from "../model.js";
+export declare const retryAfterMs: (error: unknown) => number | undefined;
+export declare const retryRequest: <T>(request: () => Promise<T>) => Promise<T>;
+export declare const attachmentByteLength: (attachment: Pick<AttachmentForUpload, "content" | "contentLength">) => number;

package/dist/utils/httpRetry.js

@@ -0,0 +1,62 @@
+import { isAxiosError } from "axios";
+const MAX_REQUEST_RETRIES = 3;
+const RETRY_BASE_DELAY_MS = 500;
+const MAX_RETRY_AFTER_DELAY_MS = 60000;
+const getAxiosCause = (error) => {
+    if (isAxiosError(error)) {
+        return error;
+    }
+    return error instanceof Error && isAxiosError(error.cause) ? error.cause : undefined;
+};
+const isRetryableRequestError = (error) => {
+    const cause = getAxiosCause(error);
+    if (!cause || cause.code === "ERR_CANCELED" || cause.name === "CanceledError") {
+        return false;
+    }
+    const status = cause.response?.status;
+    return status === undefined || status === 408 || status === 429 || status >= 500;
+};
+const parseRetryAfterMs = (error) => {
+    const headers = getAxiosCause(error)?.response?.headers;
+    const value = typeof headers?.get === "function" ? headers.get("retry-after") : headers?.["retry-after"];
+    const normalized = Array.isArray(value) ? value[0] : value;
+    if (typeof normalized !== "string" && typeof normalized !== "number") {
+        return undefined;
+    }
+    const seconds = Number(normalized);
+    if (Number.isFinite(seconds)) {
+        return Math.max(0, seconds * 1000);
+    }
+    const date = Date.parse(String(normalized));
+    return Number.isNaN(date) ? undefined : Math.max(0, date - Date.now());
+};
+export const retryAfterMs = (error) => {
+    const requestedDelayMs = parseRetryAfterMs(error);
+    return requestedDelayMs === undefined ? undefined : Math.min(requestedDelayMs, MAX_RETRY_AFTER_DELAY_MS);
+};
+export const retryRequest = async (request) => {
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            return await request();
+        }
+        catch (error) {
+            if (attempt >= MAX_REQUEST_RETRIES || !isRetryableRequestError(error)) {
+                throw error;
+            }
+            await new Promise((resolve) => setTimeout(resolve, retryAfterMs(error) ?? RETRY_BASE_DELAY_MS * 2 ** attempt));
+        }
+    }
+};
+export const attachmentByteLength = (attachment) => {
+    const { content, contentLength } = attachment;
+    if (typeof contentLength === "number") {
+        return contentLength;
+    }
+    if (Buffer.isBuffer(content)) {
+        return content.length;
+    }
+    if (typeof Blob !== "undefined" && content instanceof Blob) {
+        return content.size;
+    }
+    return 0;
+};

package/dist/utils/jobParameters.d.ts

@@ -0,0 +1,15 @@
+import { CiType } from "@allurereport/core-api";
+import type { CiDescriptor } from "@allurereport/core-api";
+import type { TestOpsJobParameter } from "../model.js";
+export declare const TESTOPS_CI_TYPE: Partial<Record<CiType, string>>;
+export declare const ciEndpoint: (ci: CiDescriptor) => string | undefined;
+export declare const externalParameters: (ci: CiDescriptor, existingJobParameters?: TestOpsJobParameter[]) => {
+    job: {
+        name: string;
+        defaultValue: string;
+    }[];
+    jobRun: {
+        name: string;
+        value: string;
+    }[];
+};

package/dist/utils/jobParameters.js

@@ -0,0 +1,39 @@
+import { env } from "node:process";
+import { CiType } from "@allurereport/core-api";
+export const TESTOPS_CI_TYPE = {
+    [CiType.Amazon]: "aws",
+    [CiType.Circle]: "circleci",
+};
+export const ciEndpoint = (ci) => {
+    try {
+        return new URL(ci.jobUrl).origin;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const externalParameters = (ci, existingJobParameters = []) => {
+    const jobParams = {};
+    const jobRunParams = {};
+    for (const { name, defaultValue } of existingJobParameters) {
+        jobParams[name] = defaultValue;
+        if (env[name]) {
+            jobRunParams[name] = env[name];
+        }
+        else if (ci.type === CiType.Bitbucket && name === "CustomName" && defaultValue) {
+            jobRunParams[name] = defaultValue;
+        }
+    }
+    if (ci.jobRunBranch) {
+        jobParams.Branch = ci.jobRunBranch;
+        jobRunParams.Branch = ci.jobRunBranch;
+    }
+    if (ci.type === CiType.Bitbucket && env.CustomName) {
+        jobParams.CustomName = env.CustomName;
+        jobRunParams.CustomName = env.CustomName;
+    }
+    return {
+        job: Object.entries(jobParams).map(([name, defaultValue]) => ({ name, defaultValue })),
+        jobRun: Object.entries(jobRunParams).map(([name, value]) => ({ name, value })),
+    };
+};

package/dist/utils/launchCategories.d.ts

@@ -0,0 +1,7 @@
+import type { CategoryDefinition } from "@allurereport/core-api";
+import type { AllureStore } from "@allurereport/plugin-api";
+import type { TestOpsClient } from "../client.js";
+import type { TestOpsPluginTestResult, UploadCategory } from "../model.js";
+export declare const categoryDisplayName: (cat: UploadCategory) => string;
+export declare const enrichWithCategories: (store: AllureStore, trs: TestOpsPluginTestResult[], contextCategories: CategoryDefinition[]) => Promise<TestOpsPluginTestResult[]>;
+export declare const syncLaunchCategories: (client: TestOpsClient, trs: TestOpsPluginTestResult[], contextCategories: CategoryDefinition[]) => Promise<Error | undefined>;

package/dist/utils/launchCategories.js

@@ -0,0 +1,97 @@
+import { toUploadCategory } from "./categories.js";
+import { unwrapStepsAttachments } from "./resolvers.js";
+export const categoryDisplayName = (cat) => cat.name ?? cat.grouping?.[0]?.name ?? cat.grouping?.[0]?.value ?? cat.grouping?.[0]?.key ?? cat.externalId;
+export const enrichWithCategories = async (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;
+    }));
+};
+const 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;
+};
+const 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 };
+        }
+    }
+};
+export const syncLaunchCategories = async (client, trs, contextCategories) => {
+    const categoryNamesByExternalId = collectCategoryNamesByExternalId(trs);
+    if (categoryNamesByExternalId.size === 0) {
+        return undefined;
+    }
+    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 category of contextCategories) {
+        if (!rankByExternalId.has(category.id)) {
+            rankByExternalId.set(category.id, category.index);
+        }
+        if (!rankByExternalId.has(category.name)) {
+            rankByExternalId.set(category.name, category.index);
+        }
+    }
+    const ranked = bulkItems.map((item, originalIndex) => ({
+        item,
+        originalIndex,
+        rank: rankByExternalId.get(item.externalId),
+    }));
+    ranked.sort((first, second) => {
+        const firstRank = first.rank ?? Number.POSITIVE_INFINITY;
+        const secondRank = second.rank ?? Number.POSITIVE_INFINITY;
+        if (firstRank !== secondRank)
+            return firstRank - secondRank;
+        return first.originalIndex - second.originalIndex;
+    });
+    const orderedBulkItems = ranked.map((rankedItem) => rankedItem.item);
+    const launchId = client.launchId;
+    if (launchId === undefined) {
+        return new Error("Launch isn't created, skipping launch categories");
+    }
+    try {
+        const created = await client.createLaunchCategoriesBulk(launchId, orderedBulkItems);
+        const categoryIdByExternalId = new Map(created.map((result) => [result.externalId, result.id]));
+        assignCreatedCategoryIds(trs, categoryIdByExternalId);
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+};

package/dist/utils/options.d.ts

@@ -1,2 +1,3 @@
 import type { TestOpsPluginOptions } from "../model.js";
+export declare const toPositiveInteger: (value: string | number | undefined) => number | undefined;
 export declare const resolvePluginOptions: (options: TestOpsPluginOptions) => Omit<TestOpsPluginOptions, "filter">;

package/dist/utils/options.js

@@ -1,12 +1,21 @@
 import { env } from "node:process";
+import { parseEnvBool } from "../gitFlow/options.js";
+export const toPositiveInteger = (value) => {
+    if (value === undefined || value === "") {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+};
 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 { ALLURE_TOKEN, ALLURE_ENDPOINT, ALLURE_PROJECT_ID, ALLURE_LAUNCH_TAGS, ALLURE_LAUNCH_NAME, ALLURE_LAUNCH_ID } = env;
+    const { accessToken = ALLURE_TOKEN, endpoint = ALLURE_ENDPOINT, projectId = ALLURE_PROJECT_ID, launchTags = ALLURE_LAUNCH_TAGS, launchName = ALLURE_LAUNCH_NAME, launchId = toPositiveInteger(ALLURE_LAUNCH_ID), autocloseLaunch, uploadRateLimit, reopenClosedLaunch = parseEnvBool(env.ALLURE_REOPEN_CLOSED_LAUNCH) ?? false, } = options;
     const tags = !launchTags
         ? []
         : Array.isArray(launchTags)
             ? launchTags
             : launchTags.split(",").map((tag) => tag.trim());
+    const resolvedLaunchId = toPositiveInteger(launchId);
     return {
         launchName: launchName || "Allure Report",
         launchTags: tags,
@@ -14,5 +23,8 @@ export const resolvePluginOptions = (options) => {
         endpoint: endpoint || "",
         projectId: projectId || "",
         ...(autocloseLaunch !== undefined ? { autocloseLaunch } : {}),
+        ...(uploadRateLimit !== undefined ? { uploadRateLimit } : {}),
+        ...(resolvedLaunchId !== undefined ? { launchId: resolvedLaunchId } : {}),
+        reopenClosedLaunch,
     };
 };

package/dist/utils/resolvers.js

@@ -39,6 +39,7 @@ export function attachmentsResolverFactory(store) {
                 originalFileName: filename,
                 contentType: attachment.contentType ?? "application/octet-stream",
                 content: body,
+                contentLength: content?.getContentLength(),
             });
         }));
         return result;

package/dist/utils/testResults.js

@@ -89,7 +89,6 @@ export const toUploadTestResultDto = (tr) => {
         trace: tr.trace,
         hostId: tr.hostId,
         threadId: tr.threadId,
-        environment: tr.environment,
         ...(category ? { category } : {}),
         ...(typeof tr.namedEnv?.id === "number" ? { namedEnv: { id: tr.namedEnv.id } } : {}),
         steps: tr.steps?.map(toUploadStepDto),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-testops",
-  "version": "3.16.0",
+  "version": "3.16.1",
   "description": "Allure Plugin TestOps",
   "keywords": [
     "allure",
@@ -32,13 +32,13 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/ci": "3.16.0",
-    "@allurereport/cli-commons": "3.16.0",
-    "@allurereport/core-api": "3.16.0",
-    "@allurereport/git": "3.16.0",
-    "@allurereport/plugin-api": "3.16.0",
-    "@allurereport/reader-api": "3.16.0",
-    "@allurereport/service": "3.16.0",
+    "@allurereport/ci": "3.16.1",
+    "@allurereport/cli-commons": "3.16.1",
+    "@allurereport/core-api": "3.16.1",
+    "@allurereport/git": "3.16.1",
+    "@allurereport/plugin-api": "3.16.1",
+    "@allurereport/reader-api": "3.16.1",
+    "@allurereport/service": "3.16.1",
     "axios": "^1.18.1",
     "form-data": "^4.0.6",
     "lodash-es": "^4.18.1",