@allurereport/plugin-testops 3.16.0 → 3.17.0

package/dist/errors.js

@@ -0,0 +1,134 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { KnownError, UnknownError } from "@allurereport/service";
+import { isAxiosError } from "axios";
+import { retryAfterMs } from "./utils/httpRetry.js";
+export var ErrorKind;
+(function (ErrorKind) {
+    ErrorKind["None"] = "none";
+    ErrorKind["ServiceTransient"] = "service_transient";
+    ErrorKind["ResourceRecoverable"] = "resource_recoverable";
+    ErrorKind["AuthTerminal"] = "auth_terminal";
+    ErrorKind["NotFoundTerminal"] = "not_found_terminal";
+    ErrorKind["PayloadTerminal"] = "payload_terminal";
+    ErrorKind["ValidationTerminal"] = "validation_terminal";
+    ErrorKind["ConflictTerminal"] = "conflict_terminal";
+    ErrorKind["Unknown"] = "unknown";
+})(ErrorKind || (ErrorKind = {}));
+const isLaunchClosedMessage = (message) => {
+    if (!message) {
+        return false;
+    }
+    const lower = message.toLowerCase();
+    return lower.includes("launch is closed") || lower.includes("closed launch");
+};
+const responseStatus = (error) => isAxiosError(error) ? error.response?.status : undefined;
+const responseMessage = (error) => {
+    if (!isAxiosError(error)) {
+        return undefined;
+    }
+    const data = error.response?.data;
+    return data?.message;
+};
+const classifyHttpStatus = (status) => {
+    if (status === 408 || status === 429 || status >= 500) {
+        return ErrorKind.ServiceTransient;
+    }
+    if (status === 423) {
+        return ErrorKind.ResourceRecoverable;
+    }
+    if (status === 401 || status === 403) {
+        return ErrorKind.AuthTerminal;
+    }
+    if (status === 404) {
+        return ErrorKind.NotFoundTerminal;
+    }
+    if (status === 413 || status === 415) {
+        return ErrorKind.PayloadTerminal;
+    }
+    if (status === 409) {
+        return ErrorKind.ConflictTerminal;
+    }
+    if (status >= 400 && status < 500) {
+        return ErrorKind.ValidationTerminal;
+    }
+    return ErrorKind.Unknown;
+};
+export const isClosedLaunchError = (error) => {
+    if (isAxiosError(error)) {
+        return isLaunchClosedMessage(responseMessage(error));
+    }
+    if (error instanceof KnownError || error instanceof UnknownError) {
+        return isLaunchClosedMessage(error.message);
+    }
+    return false;
+};
+const isCanceledError = (error) => isAxiosError(error) && (error.code === "ERR_CANCELED" || error.name === "CanceledError");
+export const classifyError = (error) => {
+    if (!error) {
+        return ErrorKind.None;
+    }
+    if (isCanceledError(error)) {
+        return ErrorKind.Unknown;
+    }
+    if (isAxiosError(error)) {
+        if (isLaunchClosedMessage(responseMessage(error))) {
+            return ErrorKind.ResourceRecoverable;
+        }
+        const status = responseStatus(error);
+        return status === undefined ? ErrorKind.ServiceTransient : classifyHttpStatus(status);
+    }
+    if (error instanceof KnownError) {
+        if (isLaunchClosedMessage(error.message)) {
+            return ErrorKind.ResourceRecoverable;
+        }
+        return typeof error.status === "number" ? classifyHttpStatus(error.status) : ErrorKind.Unknown;
+    }
+    if (error instanceof UnknownError) {
+        if (isLaunchClosedMessage(error.message)) {
+            return ErrorKind.ResourceRecoverable;
+        }
+        return ErrorKind.ServiceTransient;
+    }
+    if (error instanceof Error && (error.name === "AbortError" || /timeout/i.test(error.message))) {
+        return ErrorKind.ServiceTransient;
+    }
+    return ErrorKind.Unknown;
+};
+export const shouldRetryUpload = (error) => {
+    const kind = classifyError(error);
+    return kind === ErrorKind.ServiceTransient || kind === ErrorKind.ResourceRecoverable;
+};
+export const isPermanentUploadError = (error) => {
+    switch (classifyError(error)) {
+        case ErrorKind.AuthTerminal:
+        case ErrorKind.NotFoundTerminal:
+        case ErrorKind.PayloadTerminal:
+        case ErrorKind.ValidationTerminal:
+        case ErrorKind.ConflictTerminal:
+            return true;
+        default:
+            return false;
+    }
+};
+export const isTerminalUploadError = (error, retries, maxRetries) => isPermanentUploadError(error) || retries >= maxRetries;
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_BASE_DELAY_MS = 500;
+const DEFAULT_MAX_DELAY_MS = 5000;
+export const withUploadRetry = async (operation, options = {}) => {
+    const { maxRetries = DEFAULT_MAX_RETRIES, baseDelayMs = DEFAULT_BASE_DELAY_MS, maxDelayMs = DEFAULT_MAX_DELAY_MS, onRetry, } = options;
+    let attempt = 0;
+    for (;;) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            if (!shouldRetryUpload(error) || attempt >= maxRetries) {
+                throw error;
+            }
+            attempt += 1;
+            await onRetry?.(error, attempt);
+            const backoffMs = retryAfterMs(error) ?? Math.min(maxDelayMs, baseDelayMs * 2 ** (attempt - 1));
+            await delay(backoffMs);
+        }
+    }
+};

package/dist/gitFlow/LaunchGitFlow.js

@@ -11,6 +11,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _LaunchGitFlow_instances, _LaunchGitFlow_ci, _LaunchGitFlow_gitFlow, _LaunchGitFlow_ancestorLimit, _LaunchGitFlow_logger, _LaunchGitFlow_classify;
 import { collectGitFacts, isGitAvailable } from "@allurereport/git";
+import { applyGitFactsOverrides } from "../utils/ciOverrides.js";
 import { buildGitFlowContext, shouldAttachGitFlow } from "./context.js";
 import { projectLaunchGitContext } from "./projection.js";
 export class LaunchGitFlow {
@@ -29,11 +30,18 @@ export class LaunchGitFlow {
         if (!shouldAttachGitFlow(__classPrivateFieldGet(this, _LaunchGitFlow_gitFlow, "f"))) {
             return undefined;
         }
-        if (!isGitAvailable()) {
-            __classPrivateFieldGet(this, _LaunchGitFlow_logger, "f").warn("git CLI is not available; continuing upload without git context");
+        const gitAvailable = isGitAvailable();
+        const collected = gitAvailable ? collectGitFacts({ ancestorLimit: __classPrivateFieldGet(this, _LaunchGitFlow_ancestorLimit, "f") }) : undefined;
+        const facts = applyGitFactsOverrides(collected);
+        if (!facts?.commit) {
+            if (!gitAvailable) {
+                __classPrivateFieldGet(this, _LaunchGitFlow_logger, "f").warn("git CLI is not available; continuing upload without git context");
+            }
+            else {
+                __classPrivateFieldGet(this, _LaunchGitFlow_logger, "f").warn("Git Flow metadata could not be collected; continuing upload without git context");
+            }
             return undefined;
         }
-        const facts = collectGitFacts({ ancestorLimit: __classPrivateFieldGet(this, _LaunchGitFlow_ancestorLimit, "f") });
         const gitFlowContext = buildGitFlowContext({
             ci: __classPrivateFieldGet(this, _LaunchGitFlow_ci, "f"),
             facts,

package/dist/gitFlow/options.d.ts

@@ -1,3 +1,4 @@
 import type { TestOpsPluginOptions } from "../model.js";
 import type { ResolvedGitFlowOptions } from "./types.js";
+export declare const parseEnvBool: (value?: string) => boolean | undefined;
 export declare const resolveGitFlowOptions: (options: TestOpsPluginOptions) => ResolvedGitFlowOptions;

package/dist/gitFlow/options.js

@@ -1,6 +1,6 @@
 import { env } from "node:process";
 import { DEFAULT_ANCESTOR_LIMIT } from "@allurereport/git";
-const parseEnvBool = (value) => {
+export const parseEnvBool = (value) => {
     if (value === undefined || value === "") {
         return undefined;
     }

package/dist/model.d.ts

@@ -107,7 +107,6 @@ export type UploadTestResultDto = {
     trace?: string;
     hostId?: string;
     threadId?: string;
-    environment?: string;
     category?: UploadTestResultCategoryDto;
     namedEnv?: UploadTestResultNamedEnvDto;
     steps?: UploadTestResultStepDto[];
@@ -173,16 +172,24 @@ export type LaunchCategoryBulkResult = {
     id: number;
     externalId: string;
 };
+export type UploadRateLimit = {
+    windowMs: number;
+    maxRequestsPerWindow?: number;
+    maxFilesPerWindow?: number;
+    maxBytesPerWindow?: number;
+};
 export type TestOpsClientParams = {
     baseUrl: string;
     projectId: string;
     accessToken: string;
     limit?: number;
+    uploadRateLimit?: UploadRateLimit | false;
 };
 export type AttachmentForUpload = {
     originalFileName: string;
     contentType: string;
     content: Buffer | Blob | ReadableStream | Readable;
+    contentLength?: number;
 };
 export type FixtureResolver = (tr: TestResult) => Promise<TestOpsFixtureResult[]>;
 export type AttachmentsResolver = (tr: TestResult) => Promise<AttachmentForUpload[] | AttachmentForUpload>;
@@ -193,10 +200,13 @@ export type TestOpsUploaderOptions = {
     launchName: string;
     launchTags: string[];
     autocloseLaunch?: boolean;
+    reopenClosedLaunch?: boolean;
+    launchId?: number;
     gitFlow?: boolean;
     ancestorLimit?: number;
     filter?: (testResult: TestResult) => boolean;
     limit?: number;
+    uploadRateLimit?: UploadRateLimit | false;
 };
 export interface TestOpsFixtureResult extends Omit<TestFixtureResult, "type"> {
     type: "BEFORE" | "AFTER";
@@ -210,6 +220,21 @@ export type TestOpsSession = {
     launchId: number;
     projectId: number;
 };
+export type ExternalRunStartResponse = {
+    projectId: number;
+    launchId: number;
+    jobId?: number;
+    jobRunId?: number;
+};
+export type TestOpsJobParameter = {
+    name: string;
+    defaultValue: string;
+};
+export type TestOpsJob = {
+    id: number;
+    externalId: string;
+    parameters: TestOpsJobParameter[];
+};
 export type TestOpsLaunch = {
     id: number;
     name: string;