allure 3.0.0-beta.2 → 3.0.0-beta.21

package/dist/commands/projects/list.js

@@ -0,0 +1,75 @@
+import { readConfig } from "@allurereport/core";
+import { AllureServiceClient, KnownError } from "@allurereport/service";
+import { Command, Option } from "clipanion";
+import * as console from "node:console";
+import { exit } from "node:process";
+import prompts from "prompts";
+import { green, red, yellow } from "yoctocolors";
+import { logError } from "../../utils/logs.js";
+export class ProjectsListCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.config = Option.String("--config,-c", {
+            description: "The path Allure config file",
+        });
+        this.cwd = Option.String("--cwd", {
+            description: "The working directory for the command to run (default: current working directory)",
+        });
+    }
+    async execute() {
+        const config = await readConfig(this.cwd, this.config);
+        if (!config?.allureService?.url) {
+            console.error(red("No Allure Service URL is provided. Please provide it in the `allureService.url` field in the `allure.config.js` file"));
+            exit(1);
+            return;
+        }
+        const serviceClient = new AllureServiceClient(config.allureService);
+        try {
+            const projects = await serviceClient.projects();
+            if (projects.length === 0) {
+                console.info(yellow("No projects found. Create a new one with `allure project-create` command"));
+                return;
+            }
+            const res = await prompts({
+                type: "select",
+                name: "project",
+                message: "Select a project",
+                choices: projects.map((project) => ({
+                    title: project.name,
+                    value: project.name,
+                })),
+            });
+            if (!res?.project) {
+                console.error(red("No project selected"));
+                exit(1);
+                return;
+            }
+            const lines = [
+                "Insert following code into your Allure Config file, to enable Allure Service features for the project:",
+                "",
+                green("{"),
+                green("  allureService: {"),
+                green(`    project: "${res.project}"`),
+                green("  }"),
+                green("}"),
+            ];
+            console.info(lines.join("\n"));
+        }
+        catch (error) {
+            if (error instanceof KnownError) {
+                console.error(red(error.message));
+                exit(1);
+                return;
+            }
+            await logError("Failed to get projects due to unexpected error", error);
+            exit(1);
+        }
+    }
+}
+ProjectsListCommand.paths = [["projects", "list"]];
+ProjectsListCommand.usage = Command.Usage({
+    category: "Allure Service Projects",
+    description: "Shows list of all available projects for current user",
+    details: "This command lists all available projects for the current user and allows selecting one to get configuration information.",
+    examples: [["projects list", "List all available projects"]],
+});

package/dist/commands/qualityGate.d.ts

@@ -1,6 +1,14 @@
-type QualityGateCommandOptions = {
-    cwd?: string;
-};
-export declare const QualityGateCommandAction: (resultsDir: string, options: QualityGateCommandOptions) => Promise<void>;
-export declare const QualityGateCommand: (cli: import("cac").CAC) => void;
-export {};
+import { Command } from "clipanion";
+export declare class QualityGateCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    resultsDir: string | undefined;
+    config: string | undefined;
+    fastFail: boolean | undefined;
+    maxFailures: number | undefined;
+    minTestsCount: number | undefined;
+    successRate: number | undefined;
+    knownIssues: string | undefined;
+    cwd: string | undefined;
+    execute(): Promise<void>;
+}

package/dist/commands/qualityGate.js

@@ -1,46 +1,132 @@
-import { AllureReport, readRuntimeConfig } from "@allure/core";
-import console from "node:console";
-import process from "node:process";
-import { bold, red } from "yoctocolors";
-import { createCommand } from "../utils/commands.js";
-export const QualityGateCommandAction = async (resultsDir, options) => {
-    const cwd = options.cwd ?? process.cwd();
-    const fullConfig = await readRuntimeConfig(cwd, "./allure-report");
-    const allureReport = new AllureReport(fullConfig);
-    await allureReport.start();
-    await allureReport.readDirectory(resultsDir);
-    await allureReport.done();
-    await allureReport.validate();
-    if (allureReport.exitCode === 0) {
-        return;
+import { AllureReport, QualityGateState, readConfig, stringifyQualityGateResults } from "@allurereport/core";
+import { Command, Option } from "clipanion";
+import { glob } from "glob";
+import * as console from "node:console";
+import { realpath } from "node:fs/promises";
+import { exit, cwd as processCwd } from "node:process";
+import * as typanion from "typanion";
+import { red } from "yoctocolors";
+export class QualityGateCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.resultsDir = Option.String({
+            required: false,
+            name: "Pattern to match test results directories in the current working directory (default: ./**/allure-results)",
+        });
+        this.config = Option.String("--config,-c", {
+            description: "The path Allure config file",
+        });
+        this.fastFail = Option.Boolean("--fast-fail", {
+            description: "Force the command to fail if there are any rule failures",
+        });
+        this.maxFailures = Option.String("--max-failures", {
+            description: "The maximum number of rule failures to allow before failing the command",
+            validator: typanion.isNumber(),
+        });
+        this.minTestsCount = Option.String("--min-tests-count", {
+            description: "The minimum number of tests to run before validating the quality gate",
+            validator: typanion.isNumber(),
+        });
+        this.successRate = Option.String("--success-rate", {
+            description: "The minimum success rate to allow before failing the command",
+            validator: typanion.isNumber(),
+        });
+        this.knownIssues = Option.String("--known-issues", {
+            description: "Path to the known issues file. Updates the file and quarantines failed tests when specified",
+        });
+        this.cwd = Option.String("--cwd", {
+            description: "The working directory for the command to run (default: current working directory)",
+        });
     }
-    const failedResults = allureReport.validationResults.filter((result) => !result.success);
-    console.error(red(`Quality gate has failed with ${bold(failedResults.length.toString())} errors:\n`));
-    for (const result of failedResults) {
-        let scope = "";
-        switch (result.meta?.type) {
-            case "label":
-                scope = `(label[${result.meta.name}="${result.meta.value}"])`;
-                break;
-            case "parameter":
-                scope = `(parameter[${result.meta.name}="${result.meta.value}"])`;
-                break;
-        }
-        console.error(red(`⨯ ${bold(`${result.rule}${scope}`)}: expected ${result.expected}, actual ${result.actual}`));
+    async execute() {
+        const cwd = await realpath(this.cwd ?? processCwd());
+        const resultsDir = (this.resultsDir ?? "./**/allure-results").replace(/[\\/]$/, "");
+        const { maxFailures, minTestsCount, successRate, fastFail, knownIssues: knownIssuesPath } = this;
+        const config = await readConfig(cwd, this.config, {
+            knownIssuesPath,
+        });
+        const rules = {};
+        if (maxFailures !== undefined) {
+            rules.maxFailures = maxFailures;
+        }
+        if (minTestsCount !== undefined) {
+            rules.minTestsCount = minTestsCount;
+        }
+        if (successRate !== undefined) {
+            rules.successRate = successRate;
+        }
+        if (fastFail) {
+            rules.fastFail = fastFail;
+        }
+        config.plugins = [];
+        if (Object.keys(rules).length > 0) {
+            config.qualityGate = {
+                rules: [rules],
+            };
+        }
+        const allureReport = new AllureReport(config);
+        if (!allureReport.hasQualityGate) {
+            console.error(red("Quality gate is not configured!"));
+            console.error(red("Add qualityGate to the config or consult help to know, how to use the command with command-line arguments"));
+            exit(-1);
+            return;
+        }
+        const resultsDirectories = (await glob(resultsDir, {
+            mark: true,
+            nodir: false,
+            absolute: true,
+            dot: true,
+            windowsPathsNoEscape: true,
+            cwd,
+        })).filter((p) => /(\/|\\)$/.test(p));
+        if (resultsDirectories.length === 0) {
+            console.error("No Allure results directories found");
+            exit(0);
+            return;
+        }
+        const knownIssues = await allureReport.store.allKnownIssues();
+        const state = new QualityGateState();
+        allureReport.realtimeSubscriber.onTestResults(async (trsIds) => {
+            const trs = await Promise.all(trsIds.map((id) => allureReport.store.testResultById(id)));
+            const notHiddenTrs = trs.filter((tr) => !tr.hidden);
+            const { results, fastFailed } = await allureReport.validate({
+                trs: notHiddenTrs,
+                knownIssues,
+                state,
+            });
+            if (!fastFailed) {
+                return;
+            }
+            console.error(stringifyQualityGateResults(results));
+            exit(1);
+        });
+        await allureReport.start();
+        for (const dir of resultsDirectories) {
+            await allureReport.readDirectory(dir);
+        }
+        await allureReport.done();
+        const allTrs = await allureReport.store.allTestResults({ includeHidden: false });
+        const validationResults = await allureReport.validate({
+            trs: allTrs,
+            knownIssues,
+        });
+        if (validationResults.results.length === 0) {
+            exit(0);
+            return;
+        }
+        console.error(stringifyQualityGateResults(validationResults.results));
+        exit(1);
     }
-    console.error(red(`\nThe process has been exited with code 1`));
-    process.exit(allureReport.exitCode);
-};
-export const QualityGateCommand = createCommand({
-    name: "quality-gate <resultsDir>",
+}
+QualityGateCommand.paths = [["quality-gate"]];
+QualityGateCommand.usage = Command.Usage({
     description: "Returns status code 1 if there any test failure above specified success rate",
-    options: [
+    details: "This command validates the test results against quality gates defined in the configuration.",
+    examples: [
+        ["quality-gate ./allure-results", "Validate the test results in the ./allure-results directory"],
         [
-            "--cwd <cwd>",
-            {
-                description: "The working directory for the command to run (default: current working directory)",
-            },
+            "quality-gate ./allure-results --config custom-config.js",
+            "Validate the test results using a custom configuration file",
         ],
     ],
-    action: QualityGateCommandAction,
 });

package/dist/commands/results/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./pack.js";
+export * from "./unpack.js";

package/dist/commands/results/index.js

@@ -0,0 +1,2 @@
+export * from "./pack.js";
+export * from "./unpack.js";

package/dist/commands/results/pack.d.ts

@@ -0,0 +1,10 @@
+import { Command } from "clipanion";
+export declare class ResultsPackCommand extends Command {
+    #private;
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    resultsDir: string | undefined;
+    name: string | undefined;
+    cwd: string | undefined;
+    execute(): Promise<void>;
+}

package/dist/commands/results/pack.js

@@ -0,0 +1,106 @@
+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 _ResultsPackCommand_instances, _ResultsPackCommand_formatSize;
+import AdmZip from "adm-zip";
+import { Command, Option } from "clipanion";
+import { glob } from "glob";
+import * as console from "node:console";
+import * as fs from "node:fs/promises";
+import { realpath } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { green, red } from "yoctocolors";
+export class ResultsPackCommand extends Command {
+    constructor() {
+        super(...arguments);
+        _ResultsPackCommand_instances.add(this);
+        this.resultsDir = Option.String({
+            required: false,
+            name: "Pattern to match test results directories in the current working directory (default: ./**/allure-results)",
+        });
+        this.name = Option.String("--name", {
+            description: "The archive name (default: allure-results.zip)",
+        });
+        this.cwd = Option.String("--cwd", {
+            description: "The working directory for the command to run (default: current working directory)",
+        });
+    }
+    async execute() {
+        const cwd = await realpath(this.cwd ?? process.cwd());
+        const resultsDir = (this.resultsDir ?? "./**/allure-results").replace(/[\\/]$/, "");
+        const archiveName = this.name ?? "allure-results.zip";
+        const resultsDirectories = (await glob(resultsDir, {
+            mark: true,
+            nodir: false,
+            dot: true,
+            absolute: true,
+            windowsPathsNoEscape: true,
+            cwd,
+        })).filter((p) => /(\/|\\)$/.test(p));
+        const resultsFiles = new Set();
+        if (resultsDirectories.length === 0) {
+            console.log(red(`No test results directories found matching pattern: ${resultsDir}`));
+            return;
+        }
+        for (const dir of resultsDirectories) {
+            const files = await fs.readdir(dir);
+            if (files.length === 0) {
+                continue;
+            }
+            for (const file of files) {
+                resultsFiles.add(resolve(dir, file));
+            }
+        }
+        const outputPath = join(cwd, archiveName);
+        const zip = new AdmZip();
+        for (const file of resultsFiles) {
+            try {
+                const stats = await fs.stat(file);
+                if (stats.isFile()) {
+                    zip.addLocalFile(file, "", basename(file));
+                }
+            }
+            catch (error) {
+                console.log(red(`Error adding file ${file} to archive: ${error.message}`));
+            }
+        }
+        try {
+            zip.writeZip(outputPath);
+            const stats = await fs.stat(outputPath);
+            console.log(green(`Archive created successfully: ${outputPath}`));
+            console.log(green(`Total size: ${__classPrivateFieldGet(this, _ResultsPackCommand_instances, "m", _ResultsPackCommand_formatSize).call(this, stats.size)}. ${resultsFiles.size} results files have been collected`));
+        }
+        catch (err) {
+            console.log(red(`Error creating archive: ${err.message}`));
+            throw err;
+        }
+    }
+}
+_ResultsPackCommand_instances = new WeakSet(), _ResultsPackCommand_formatSize = function _ResultsPackCommand_formatSize(bytes) {
+    const units = ["bytes", "KB", "MB", "GB"];
+    let size = bytes;
+    let unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+        size /= 1024;
+        unitIndex++;
+    }
+    if (bytes === 0) {
+        return "0 bytes";
+    }
+    return unitIndex === 0 ? `${Math.round(size)} ${units[unitIndex]}` : `${size.toFixed(2)} ${units[unitIndex]}`;
+};
+ResultsPackCommand.paths = [["results", "pack"]];
+ResultsPackCommand.usage = Command.Usage({
+    description: "Creates .zip archive with test results",
+    category: "Allure Test Results",
+    details: "This command creates .zip archive with all test results which can be collected in the project",
+    examples: [
+        ["results pack", "Creates .zip archive with test results in directories matched to ./**/allure-results pattern"],
+        [
+            "results pack ./**/foo/**/my-results --name results.zip",
+            "Creates results.zip archive with test results in directories matched to ./**/foo/**/my-results pattern",
+        ],
+    ],
+});

package/dist/commands/results/unpack.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "clipanion";
+export declare class ResultsUnpackCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    output: string;
+    archives: string[];
+    cwd: string | undefined;
+    execute(): Promise<void>;
+}

package/dist/commands/results/unpack.js

@@ -0,0 +1,79 @@
+import AdmZip from "adm-zip";
+import { Command, Option } from "clipanion";
+import * as console from "node:console";
+import * as fs from "node:fs/promises";
+import { realpath } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import { green, red } from "yoctocolors";
+export class ResultsUnpackCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.output = Option.String("--output", "./allure-results", {
+            description: "Output directory where the archives should be unarchived to (default: ./allure-results)",
+        });
+        this.archives = Option.Rest({
+            name: "List of test results archives to extract separated by spaces. If no archives are provided, the command will extract allure-results.zip archive",
+        });
+        this.cwd = Option.String("--cwd", {
+            description: "The working directory for the command to run (default: current working directory)",
+        });
+    }
+    async execute() {
+        const cwd = await realpath(this.cwd ?? process.cwd());
+        const outputDir = resolve(cwd, this.output);
+        const archives = this.archives.length > 0 ? this.archives : ["allure-results.zip"];
+        try {
+            await fs.mkdir(outputDir, { recursive: true });
+        }
+        catch (ignored) { }
+        let successCount = 0;
+        let failCount = 0;
+        for (const archivePath of archives) {
+            const resolvedPath = resolve(cwd, archivePath);
+            try {
+                await fs.access(resolvedPath);
+                console.log(`Extracting ${resolvedPath} to ${outputDir}`);
+                try {
+                    const zip = new AdmZip(resolvedPath);
+                    zip.extractAllTo(outputDir, true);
+                    console.log(green(`Successfully extracted ${basename(resolvedPath)}`));
+                    successCount++;
+                }
+                catch (err) {
+                    console.log(red(`Error extracting ${basename(resolvedPath)}: ${err.message}`));
+                    failCount++;
+                }
+            }
+            catch (error) {
+                console.log(red(`Error accessing archive ${resolvedPath}: ${error.message}`));
+                failCount++;
+            }
+        }
+        console.log(green(`Extraction complete. Successfully extracted ${successCount} archive(s).`));
+        if (failCount > 0) {
+            console.log(red(`Failed to extract ${failCount} archive(s).`));
+            return;
+        }
+    }
+}
+ResultsUnpackCommand.paths = [["results", "unpack"]];
+ResultsUnpackCommand.usage = Command.Usage({
+    description: "Extracts test results from .zip archives",
+    category: "Allure Test Results",
+    details: "This command extracts test results from .zip archives to the specified output directory",
+    examples: [
+        ["results unpack", "Extract test results from allure-results.zip to the default directory (./allure-results)"],
+        [
+            "results unpack results.zip",
+            "Extract test results from results.zip to the default directory (./allure-results)",
+        ],
+        [
+            "results unpack results1.zip results2.zip results3.zip",
+            "Extract test results from multiple archives to the default directory",
+        ],
+        [
+            "results unpack --output ./mydir results1.zip results2.zip results3.zip",
+            "Extract test results from multiple archives to the specified directory (./mydir)",
+        ],
+    ],
+});

package/dist/commands/run.d.ts

@@ -1,10 +1,24 @@
-export type RunCommandOptions = {
-    config?: string;
-    cwd?: string;
-    output?: string;
-    reportName?: string;
-    rerun?: number;
-    silent?: boolean;
-} & Record<"--", string[]>;
-export declare const RunCommandAction: (options: RunCommandOptions) => Promise<never>;
-export declare const RunCommand: (cli: import("cac").CAC) => void;
+import type { QualityGateValidationResult } from "@allurereport/plugin-api";
+import { Command } from "clipanion";
+export type TestProcessResult = {
+    code: number | null;
+    stdout: string;
+    stderr: string;
+    qualityGateResults: QualityGateValidationResult[];
+};
+export declare class RunCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    config: string | undefined;
+    cwd: string | undefined;
+    output: string | undefined;
+    reportName: string | undefined;
+    rerun: string | undefined;
+    silent: boolean | undefined;
+    ignoreLogs: boolean | undefined;
+    stage: string | undefined;
+    environment: string | undefined;
+    commandToRun: string[];
+    get logs(): "pipe" | "inherit" | "ignore";
+    execute(): Promise<void>;
+}