@allurereport/plugin-testops 3.3.1 → 3.4.1

package/dist/logger.js

@@ -0,0 +1,129 @@
+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 _Logger_instances, _Logger_level, _Logger_isLogLevel, _Logger_prefix;
+import console from "node:console";
+import { env } from "node:process";
+import { inspect } from "node:util";
+import ProgressBar from "progress";
+import { blue, bold, cyan, dim, gray, red, yellow } from "yoctocolors";
+const logLevelsPriority = {
+    silent: Number.MAX_SAFE_INTEGER,
+    verbose: 0,
+    debug: 1,
+    info: 2,
+    warn: 3,
+    error: 4,
+};
+function getLogLevelFromEnv() {
+    if (env.LOG_LEVEL) {
+        return env.LOG_LEVEL;
+    }
+    if (env.ALLURE_LOG_LEVEL) {
+        return env.ALLURE_LOG_LEVEL;
+    }
+    if (env.NODE_ENV === "development") {
+        return "debug";
+    }
+    return "info";
+}
+export class Logger {
+    constructor(name) {
+        _Logger_instances.add(this);
+        this.name = name;
+        _Logger_level.set(this, getLogLevelFromEnv());
+        _Logger_prefix.set(this, cyan(bold(`[${this.name}]:`)));
+    }
+    progressBarCounter(message, total) {
+        if (__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_isLogLevel).call(this, "silent")) {
+            return {
+                tick: () => { },
+                update: () => { },
+                terminate: () => { },
+            };
+        }
+        const progressBar = new ProgressBar(`${__classPrivateFieldGet(this, _Logger_prefix, "f")} ${blue(message)} [:bar] :current/:total`, {
+            total,
+            width: 20,
+        });
+        return progressBar;
+    }
+    progressBar(message) {
+        if (__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_isLogLevel).call(this, "silent")) {
+            return {
+                update: () => { },
+                terminate: () => { },
+            };
+        }
+        const progressBar = new ProgressBar(`${__classPrivateFieldGet(this, _Logger_prefix, "f")} ${blue(message)} [:bar] :percent`, {
+            total: 100,
+            width: 20,
+        });
+        return progressBar;
+    }
+    verbose(message) {
+        if (!__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_isLogLevel).call(this, "verbose")) {
+            return;
+        }
+        if (typeof message === "string") {
+            console.log(`${__classPrivateFieldGet(this, _Logger_prefix, "f")} ${dim(gray(message))}`);
+            return;
+        }
+        console.log(`${__classPrivateFieldGet(this, _Logger_prefix, "f")} ${dim(gray(JSON.stringify(message, null, 2)))}`);
+    }
+    debug(message) {
+        if (!__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_isLogLevel).call(this, "debug")) {
+            return;
+        }
+        if (typeof message === "string") {
+            console.debug(`${__classPrivateFieldGet(this, _Logger_prefix, "f")} ${gray(message)}`);
+            return;
+        }
+        console.debug(`${__classPrivateFieldGet(this, _Logger_prefix, "f")} ${gray(JSON.stringify(message, null, 2))}`);
+    }
+    newLine() {
+        console.log("\n");
+    }
+    info(message) {
+        if (!__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_isLogLevel).call(this, "info")) {
+            return;
+        }
+        if (typeof message === "string") {
+            console.info(`${__classPrivateFieldGet(this, _Logger_prefix, "f")} ${blue(message)}`);
+            return;
+        }
+        console.info(`${__classPrivateFieldGet(this, _Logger_prefix, "f")} ${blue(JSON.stringify(message, null, 2))}`);
+    }
+    warn(message) {
+        if (!__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_isLogLevel).call(this, "warn")) {
+            return;
+        }
+        if (typeof message === "string") {
+            console.warn(`${__classPrivateFieldGet(this, _Logger_prefix, "f")} ${yellow(message)}`);
+            return;
+        }
+        console.warn(`${__classPrivateFieldGet(this, _Logger_prefix, "f")} ${yellow(JSON.stringify(message, null, 2))}`);
+    }
+    error(message) {
+        if (!__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_isLogLevel).call(this, "error")) {
+            return;
+        }
+        if (typeof message === "string") {
+            console.error(`${__classPrivateFieldGet(this, _Logger_prefix, "f")} ${red(message)}`);
+            return;
+        }
+        console.error(`${__classPrivateFieldGet(this, _Logger_prefix, "f")} ${red(JSON.stringify(message, null, 2))}`);
+    }
+    inspect(value) {
+        if (!__classPrivateFieldGet(this, _Logger_instances, "m", _Logger_isLogLevel).call(this, "debug")) {
+            return;
+        }
+        console.log(`${__classPrivateFieldGet(this, _Logger_prefix, "f")} inspect`);
+        inspect(value);
+    }
+}
+_Logger_level = new WeakMap(), _Logger_prefix = new WeakMap(), _Logger_instances = new WeakSet(), _Logger_isLogLevel = function _Logger_isLogLevel(level) {
+    return logLevelsPriority[__classPrivateFieldGet(this, _Logger_level, "f")] <= logLevelsPriority[level];
+};

package/dist/model.d.ts

@@ -1,15 +1,76 @@
-import type { AttachmentLink, TestResult } from "@allurereport/core-api";
-export type TestopsUploaderOptions = {
+import type { Readable } from "node:stream";
+import type { AttachmentLink, TestFixtureResult, TestResult } from "@allurereport/core-api";
+export type UploadCategoryGrouping = {
+    key: string;
+    value?: string;
+    name?: string;
+    type?: string;
+};
+export type UploadCategory = {
+    externalId: string;
+    name?: string;
+    grouping?: UploadCategoryGrouping[];
+    expand?: boolean;
+    hide?: boolean;
+};
+export type TestResultWithCategories = Pick<TestResult, "status" | "labels" | "error" | "flaky" | "duration" | "transition" | "environment"> & {
+    categories?: {
+        id?: string;
+        name: string;
+        grouping?: UploadCategoryGrouping[];
+        hide?: boolean;
+        expand?: boolean;
+    }[];
+};
+export interface TestOpsPluginTestResult extends TestResult {
+    category?: UploadCategory & {
+        id?: number;
+    };
+    namedEnv?: {
+        id: number;
+    };
+    message?: string;
+    trace?: string;
+    uuid?: string;
+}
+export type LaunchCategoryBulkItem = {
+    externalId: string;
+    name: string;
+    expand?: boolean;
+    hide?: boolean;
+};
+export type LaunchCategoryBulkResult = {
+    id: number;
+    externalId: string;
+};
+export type TestOpsClientParams = {
+    baseUrl: string;
+    projectId: string;
+    accessToken: string;
+    limit?: number;
+};
+export type AttachmentForUpload = {
+    originalFileName: string;
+    contentType: string;
+    content: Buffer | Blob | ReadableStream | Readable;
+};
+export type FixtureResolver = (tr: TestResult) => Promise<TestOpsFixtureResult[]>;
+export type AttachmentsResolver = (tr: TestResult) => Promise<AttachmentForUpload[] | AttachmentForUpload>;
+export type TestOpsUploaderOptions = {
     endpoint: string;
     accessToken: string;
     projectId: string;
     launchName: string;
     launchTags: string[];
+    autocloseLaunch?: boolean;
     filter?: (testResult: TestResult) => boolean;
     limit?: number;
 };
+export interface TestOpsFixtureResult extends Omit<TestFixtureResult, "type"> {
+    type: "BEFORE" | "AFTER";
+}
 export type TemplateManifest = Record<string, string>;
-export type TestopsPluginOptions = TestopsUploaderOptions;
+export type TestOpsPluginOptions = TestOpsUploaderOptions;
 export type TestOpsSession = {
     id: number;
     jobId: number;
@@ -30,6 +91,21 @@ export type TestOpsLaunch = {
     createdDate: number;
     lastModifiedDate: number;
 };
-export type TestResultWithAttachments = TestResult & {
+export interface TestResultWithAttachments extends TestResult {
     attachments: AttachmentLink[];
+}
+export type TestOpsNamedEnv = {
+    id: number;
+    name: string;
+    externalId: string;
+    jobRunId?: number;
+    launchId?: number;
+};
+export type TestOpsLaunchQualityGate = {
+    id: number;
+    launchId: number;
+    jobRunId?: number;
+    namedEnvId?: number;
+    name: string;
+    message?: string;
 };

package/dist/plugin.d.ts

@@ -1,12 +1,12 @@
-import { type AllureStore, type Plugin, type PluginContext, type PluginSummary } from "@allurereport/plugin-api";
-import type { TestopsPluginOptions } from "./model.js";
-export declare class TestopsPlugin implements Plugin {
+import { type AllureStore, type Plugin, type PluginContext } from "@allurereport/plugin-api";
+import type { TestOpsPluginOptions } from "./model.js";
+export declare class TestOpsPlugin implements Plugin {
     #private;
-    readonly options: TestopsPluginOptions;
-    constructor(options: TestopsPluginOptions);
+    readonly options: TestOpsPluginOptions;
+    constructor(options: TestOpsPluginOptions);
     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>;
+    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<import("@allurereport/plugin-api").PluginSummary | undefined>;
 }