@allurereport/plugin-testops 3.15.0 → 3.16.1

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/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/logger.d.ts

@@ -1,8 +1,10 @@
+type LogLevel = "silent" | "verbose" | "debug" | "info" | "warn" | "error";
 type JSONMessage = Record<string, unknown> | Array<unknown>;
 export declare class Logger {
     #private;
     private readonly loggerName;
-    constructor(loggerName: string);
+    constructor(loggerName: string, logLevel?: LogLevel);
+    setLogLevel(logLevel: LogLevel): void;
     verbose(message: string | JSONMessage): void;
     debug(message: string | JSONMessage): void;
     newLine(): void;

package/dist/logger.js

@@ -35,13 +35,17 @@ function getLogLevelFromEnv() {
     return "info";
 }
 export class Logger {
-    constructor(loggerName) {
+    constructor(loggerName, logLevel) {
         _Logger_instances.add(this);
         this.loggerName = loggerName;
-        _Logger_level.set(this, getLogLevelFromEnv());
+        _Logger_level.set(this, void 0);
         _Logger_prefix.set(this, void 0);
+        __classPrivateFieldSet(this, _Logger_level, logLevel ?? getLogLevelFromEnv(), "f");
         __classPrivateFieldSet(this, _Logger_prefix, cyan(bold(`[${this.loggerName}]:`)), "f");
     }
+    setLogLevel(logLevel) {
+        __classPrivateFieldSet(this, _Logger_level, logLevel, "f");
+    }
     verbose(message) {
         if (!__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_isLogLevel).call(this, "verbose")) {
             return;

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;