allure 3.0.0-beta.16 → 3.0.0-beta.18

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,22 @@
-export type RunCommandOptions = {
-    config?: string;
-    cwd?: string;
-    output?: string;
-    reportName?: string;
-    rerun?: number;
-    silent?: boolean;
-} & Record<"--", string[]>;
-export declare const RunCommandAction: (options: RunCommandOptions) => Promise<void>;
-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;
+    commandToRun: string[];
+    get logs(): "pipe" | "ignore" | "inherit";
+    execute(): Promise<void>;
+}

package/dist/commands/run.js

@@ -1,19 +1,21 @@
-import { AllureReport, isFileNotFoundError, readConfig } from "@allurereport/core";
+import { AllureReport, QualityGateState, isFileNotFoundError, readConfig, stringifyQualityGateResults, } from "@allurereport/core";
 import { createTestPlan } from "@allurereport/core-api";
 import { allureResultsDirectoriesWatcher, delayedFileProcessingWatcher, newFilesInDirectoryWatcher, } from "@allurereport/directory-watcher";
 import Awesome from "@allurereport/plugin-awesome";
-import { PathResultFile } from "@allurereport/reader-api";
+import { BufferResultFile, PathResultFile } from "@allurereport/reader-api";
 import { KnownError } from "@allurereport/service";
+import { Command, Option } from "clipanion";
 import * as console from "node:console";
 import { mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
-import process from "node:process";
+import process, { exit } from "node:process";
+import terminate from "terminate/promise";
 import { red } from "yoctocolors";
-import { createCommand } from "../utils/commands.js";
 import { logTests, runProcess, terminationOf } from "../utils/index.js";
 import { logError } from "../utils/logs.js";
-const runTests = async (allureReport, cwd, command, commandArgs, environment, silent) => {
+const runTests = async (params) => {
+    const { allureReport, knownIssues, cwd, command, commandArgs, logs, environment, withQualityGate, silent } = params;
     let testProcessStarted = false;
     const allureResultsWatchers = new Map();
     const processWatcher = delayedFileProcessingWatcher(async (path) => {
@@ -47,43 +49,147 @@ const runTests = async (allureReport, cwd, command, commandArgs, environment, si
     await allureResultsWatch.initialScan();
     testProcessStarted = true;
     const beforeProcess = Date.now();
-    const testProcess = runProcess(command, commandArgs, cwd, environment, silent);
+    const testProcess = runProcess({
+        command,
+        commandArgs,
+        cwd,
+        environment,
+        logs,
+    });
+    const qualityGateState = new QualityGateState();
+    let qualityGateUnsub;
+    let qualityGateResults = [];
+    let testProcessStdout = "";
+    let testProcessStderr = "";
+    if (withQualityGate) {
+        qualityGateUnsub = allureReport.realtimeSubscriber.onTestResults(async (testResults) => {
+            const trs = await Promise.all(testResults.map((tr) => allureReport.store.testResultById(tr)));
+            const filteredTrs = trs.filter((tr) => tr !== undefined);
+            if (!filteredTrs.length) {
+                return;
+            }
+            const { results, fastFailed } = await allureReport.validate({
+                trs: filteredTrs,
+                state: qualityGateState,
+                knownIssues,
+            });
+            if (!fastFailed) {
+                return;
+            }
+            allureReport.realtimeDispatcher.sendQualityGateResults(results);
+            qualityGateResults = results;
+            try {
+                await terminate(testProcess.pid, "SIGTERM");
+            }
+            catch (err) {
+                if (err.message.includes("kill ESRCH")) {
+                    return;
+                }
+                throw err;
+            }
+        });
+    }
+    if (logs === "pipe") {
+        testProcess.stdout?.setEncoding("utf8").on?.("data", (data) => {
+            testProcessStdout += data;
+            if (silent) {
+                return;
+            }
+            process.stdout.write(data);
+        });
+        testProcess.stderr?.setEncoding("utf8").on?.("data", async (data) => {
+            testProcessStderr += data;
+            if (silent) {
+                return;
+            }
+            process.stderr.write(data);
+        });
+    }
     const code = await terminationOf(testProcess);
     const afterProcess = Date.now();
-    console.log(`process finished with code ${code ?? 0} (${afterProcess - beforeProcess})ms`);
+    if (code !== null) {
+        console.log(`process finished with code ${code} (${afterProcess - beforeProcess}ms)`);
+    }
+    else {
+        console.log(`process terminated (${afterProcess - beforeProcess}ms)`);
+    }
     await allureResultsWatch.abort();
     for (const [ar, watcher] of allureResultsWatchers) {
         await watcher.abort();
         allureResultsWatchers.delete(ar);
     }
     await processWatcher.abort();
-    return code;
+    qualityGateUnsub?.();
+    return {
+        code,
+        stdout: testProcessStdout,
+        stderr: testProcessStderr,
+        qualityGateResults,
+    };
 };
-export const RunCommandAction = async (options) => {
-    const args = options["--"];
-    if (!args || !args.length) {
-        throw new Error("expecting command to be specified after --, e.g. allure run -- npm run test");
-    }
-    const before = new Date().getTime();
-    process.on("exit", (exitCode) => {
-        const after = new Date().getTime();
-        console.log(`exit code ${exitCode} (${after - before}ms)`);
-    });
-    const command = args[0];
-    const commandArgs = args.slice(1);
-    const cwd = await realpath(options.cwd ?? process.cwd());
-    console.log(`${command} ${commandArgs.join(" ")}`);
-    const { config: configPath, output, reportName, rerun: maxRerun = 0, silent = false } = options;
-    const config = await readConfig(cwd, configPath, { output, name: reportName });
-    try {
-        await rm(config.output, { recursive: true });
+export class RunCommand 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)",
+        });
+        this.output = Option.String("--output,-o", {
+            description: "The output file name, allure.csv by default. Accepts absolute paths (default: ./allure-report)",
+        });
+        this.reportName = Option.String("--report-name,--name", {
+            description: "The report name (default: Allure Report)",
+        });
+        this.rerun = Option.String("--rerun", {
+            description: "The number of reruns for failed tests (default: 0)",
+        });
+        this.silent = Option.Boolean("--silent", {
+            description: "Don't pipe the process output logs to console (default: 0)",
+        });
+        this.ignoreLogs = Option.Boolean("--ignore-logs", {
+            description: "Prevent logs attaching to the report (default: false)",
+        });
+        this.commandToRun = Option.Rest();
     }
-    catch (e) {
-        if (!isFileNotFoundError(e)) {
-            console.error("could not clean output directory", e);
+    get logs() {
+        if (this.silent) {
+            return this.ignoreLogs ? "ignore" : "pipe";
         }
+        return this.ignoreLogs ? "inherit" : "pipe";
     }
-    try {
+    async execute() {
+        const args = this.commandToRun.filter((arg) => arg !== "--");
+        if (!args || !args.length) {
+            throw new Error("expecting command to be specified after --, e.g. allure run -- npm run test");
+        }
+        const before = new Date().getTime();
+        process.on("exit", (exitCode) => {
+            const after = new Date().getTime();
+            console.log(`exit code ${exitCode} (${after - before}ms)`);
+        });
+        const command = args[0];
+        const commandArgs = args.slice(1);
+        const cwd = await realpath(this.cwd ?? process.cwd());
+        console.log(`${command} ${commandArgs.join(" ")}`);
+        const maxRerun = this.rerun ? parseInt(this.rerun, 10) : 0;
+        const config = await readConfig(cwd, this.config, { output: this.output, name: this.reportName });
+        const withQualityGate = !!config.qualityGate;
+        const withRerun = !!this.rerun;
+        if (withQualityGate && withRerun) {
+            console.error(red("At this moment, quality gate and rerun can't be used at the same time!"));
+            console.error(red("Consider using --rerun=0 or disable quality gate in the config to run tests"));
+            exit(-1);
+        }
+        try {
+            await rm(config.output, { recursive: true });
+        }
+        catch (e) {
+            if (!isFileNotFoundError(e)) {
+                console.error("could not clean output directory", e);
+            }
+        }
         const allureReport = new AllureReport({
             ...config,
             realTime: false,
@@ -102,81 +208,118 @@ export const RunCommandAction = async (options) => {
                     ]),
             ],
         });
+        const knownIssues = await allureReport.store.allKnownIssues();
         await allureReport.start();
-        let code = await runTests(allureReport, cwd, command, commandArgs, {}, silent);
-        for (let rerun = 0; rerun < maxRerun; rerun++) {
-            const failed = await allureReport.store.failedTestResults();
-            if (failed.length === 0) {
-                console.log("no failed tests is detected.");
-                break;
-            }
-            const testPlan = createTestPlan(failed);
-            console.log(`rerun number ${rerun} of ${testPlan.tests.length} tests:`);
-            logTests(failed);
-            const tmpDir = await mkdtemp(join(tmpdir(), "allure-run-"));
-            const testPlanPath = resolve(tmpDir, `${rerun}-testplan.json`);
-            await writeFile(testPlanPath, JSON.stringify(testPlan));
-            code = await runTests(allureReport, cwd, command, commandArgs, {
-                ALLURE_TESTPLAN_PATH: testPlanPath,
-                ALLURE_RERUN: `${rerun}`,
-            }, silent);
-            await rm(tmpDir, { recursive: true });
-            logTests(await allureReport.store.allTestResults());
+        const globalExitCode = {
+            original: 0,
+            actual: undefined,
+        };
+        let qualityGateResults;
+        let testProcessResult = null;
+        try {
+            testProcessResult = await runTests({
+                logs: this.logs,
+                silent: this.silent,
+                allureReport,
+                knownIssues,
+                cwd,
+                command,
+                commandArgs,
+                environment: {},
+                withQualityGate,
+            });
+            for (let rerun = 0; rerun < maxRerun; rerun++) {
+                const failed = await allureReport.store.failedTestResults();
+                if (failed.length === 0) {
+                    console.log("no failed tests is detected.");
+                    break;
+                }
+                const testPlan = createTestPlan(failed);
+                console.log(`rerun number ${rerun} of ${testPlan.tests.length} tests:`);
+                logTests(failed);
+                const tmpDir = await mkdtemp(join(tmpdir(), "allure-run-"));
+                const testPlanPath = resolve(tmpDir, `${rerun}-testplan.json`);
+                await writeFile(testPlanPath, JSON.stringify(testPlan));
+                testProcessResult = await runTests({
+                    silent: this.silent,
+                    logs: this.logs,
+                    allureReport,
+                    knownIssues,
+                    cwd,
+                    command,
+                    commandArgs,
+                    environment: {
+                        ALLURE_TESTPLAN_PATH: testPlanPath,
+                        ALLURE_RERUN: `${rerun}`,
+                    },
+                    withQualityGate,
+                });
+                await rm(tmpDir, { recursive: true });
+                logTests(await allureReport.store.allTestResults());
+            }
+            const trs = await allureReport.store.allTestResults({ includeHidden: false });
+            qualityGateResults = testProcessResult?.qualityGateResults ?? [];
+            if (withQualityGate && !qualityGateResults?.length) {
+                const { results } = await allureReport.validate({
+                    trs,
+                    knownIssues,
+                });
+                qualityGateResults = results;
+            }
+            if (qualityGateResults?.length) {
+                const qualityGateMessage = stringifyQualityGateResults(qualityGateResults);
+                console.error(qualityGateMessage);
+                allureReport.realtimeDispatcher.sendQualityGateResults(qualityGateResults);
+            }
+            globalExitCode.original = testProcessResult?.code ?? -1;
+            if (withQualityGate) {
+                globalExitCode.actual = qualityGateResults.length > 0 ? 1 : 0;
+            }
         }
-        await allureReport.done();
-        await allureReport.validate();
-        process.exit(code ?? allureReport.exitCode);
-    }
-    catch (error) {
-        if (error instanceof KnownError) {
-            console.error(red(error.message));
-            process.exit(1);
-            return;
+        catch (error) {
+            globalExitCode.actual = 1;
+            if (error instanceof KnownError) {
+                console.error(red(error.message));
+                allureReport.realtimeDispatcher.sendGlobalError({
+                    message: error.message,
+                });
+            }
+            else {
+                await logError("Failed to run tests using Allure due to unexpected error", error);
+                allureReport.realtimeDispatcher.sendGlobalError({
+                    message: error.message,
+                    trace: error.stack,
+                });
+            }
         }
-        await logError("Failed to run tests using Allure due to unexpected error", error);
-        process.exit(1);
+        const processFailed = Math.abs(globalExitCode.actual ?? globalExitCode.original) !== 0;
+        if (!this.ignoreLogs && testProcessResult?.stdout) {
+            const stdoutResultFile = new BufferResultFile(Buffer.from(testProcessResult.stdout, "utf8"), "stdout.txt");
+            stdoutResultFile.contentType = "text/plain";
+            allureReport.realtimeDispatcher.sendGlobalAttachment(stdoutResultFile);
+        }
+        if (!this.ignoreLogs && testProcessResult?.stderr) {
+            const stderrResultFile = new BufferResultFile(Buffer.from(testProcessResult.stderr, "utf8"), "stderr.txt");
+            stderrResultFile.contentType = "text/plain";
+            allureReport.realtimeDispatcher.sendGlobalAttachment(stderrResultFile);
+            if (processFailed) {
+                allureReport.realtimeDispatcher.sendGlobalError({
+                    message: "Test process has failed",
+                    trace: testProcessResult.stderr,
+                });
+            }
+        }
+        allureReport.realtimeDispatcher.sendGlobalExitCode(globalExitCode);
+        await allureReport.done();
+        exit(globalExitCode.actual ?? globalExitCode.original);
     }
-};
-export const RunCommand = createCommand({
-    name: "run",
+}
+RunCommand.paths = [["run"]];
+RunCommand.usage = Command.Usage({
     description: "Run specified command",
-    options: [
-        [
-            "--config, -c <file>",
-            {
-                description: "The path Allure config file",
-            },
-        ],
-        [
-            "--cwd <cwd>",
-            {
-                description: "The working directory for the command to run (Default: current working directory)",
-            },
-        ],
-        [
-            "--output, -o <file>",
-            {
-                description: "The output file name, allure.csv by default. Accepts absolute paths (Default: ./allure-report)",
-            },
-        ],
-        [
-            "--report-name, --name <string>",
-            {
-                description: "The report name (Default: Allure Report)",
-            },
-        ],
-        [
-            "--rerun <number>",
-            {
-                description: "The number of reruns for failed tests (Default: 0)",
-            },
-        ],
-        [
-            "--silent",
-            {
-                description: "Don't pipe the process output logs to console (Default: 0)",
-            },
-        ],
+    details: "This command runs the specified command and collects Allure results.",
+    examples: [
+        ["run -- npm run test", "Run npm run test and collect Allure results"],
+        ["run --rerun 3 -- npm run test", "Run npm run test and rerun failed tests up to 3 times"],
     ],
-    action: RunCommandAction,
 });

package/dist/commands/slack.d.ts

@@ -1,9 +1,11 @@
-type CommandOptions = {
-    cwd?: string;
-    config?: string;
+import { Command } from "clipanion";
+export declare class SlackCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    resultsDir: string;
+    config: string | undefined;
+    cwd: string | undefined;
     token: string;
     channel: string;
-};
-export declare const SlackCommandAction: (resultsDir: string, options: CommandOptions) => Promise<void>;
-export declare const SlackCommand: (cli: import("cac").CAC) => void;
-export {};
+    execute(): Promise<void>;
+}

package/dist/commands/slack.js

@@ -1,58 +1,61 @@
-import { AllureReport, enforcePlugin, readConfig } from "@allurereport/core";
+import { AllureReport, readConfig } from "@allurereport/core";
 import SlackPlugin from "@allurereport/plugin-slack";
+import { Command, Option } from "clipanion";
 import * as console from "node:console";
 import { realpath } from "node:fs/promises";
 import process from "node:process";
-import { createCommand } from "../utils/commands.js";
-export const SlackCommandAction = async (resultsDir, options) => {
-    const cwd = await realpath(options.cwd ?? process.cwd());
-    const before = new Date().getTime();
-    const { config: configPath, token, channel } = options;
-    const defaultSlackOptions = {
-        token,
-        channel,
-    };
-    const config = enforcePlugin(await readConfig(cwd, configPath), {
-        id: "slack",
-        enabled: true,
-        options: defaultSlackOptions,
-        plugin: new SlackPlugin(defaultSlackOptions),
-    });
-    const allureReport = new AllureReport(config);
-    await allureReport.start();
-    await allureReport.readDirectory(resultsDir);
-    await allureReport.done();
-    const after = new Date().getTime();
-    console.log(`the report successfully generated (${after - before}ms)`);
-};
-export const SlackCommand = createCommand({
-    name: "slack <resultsDir>",
-    description: "Posts test results into Slack Channel",
-    options: [
-        [
-            "--config, -c <file>",
-            {
-                description: "The path Allure config file",
-            },
-        ],
-        [
-            "--cwd <cwd>",
-            {
-                description: "The working directory for the command to run (Default: current working directory)",
-            },
-        ],
-        [
-            "--token, -t <token>",
+export class SlackCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.resultsDir = Option.String({ required: true, name: "The directory with Allure results" });
+        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)",
+        });
+        this.token = Option.String("--token,-t", {
+            description: "Slack Bot User OAuth Token",
+            required: true,
+        });
+        this.channel = Option.String("--channel", {
+            description: "Slack channelId",
+            required: true,
+        });
+    }
+    async execute() {
+        const cwd = await realpath(this.cwd ?? process.cwd());
+        const before = new Date().getTime();
+        const defaultSlackOptions = {
+            token: this.token,
+            channel: this.channel,
+        };
+        const config = await readConfig(cwd, this.config);
+        config.plugins = [
             {
-                description: "Slack Bot User OAuth Token",
+                id: "slack",
+                enabled: true,
+                options: defaultSlackOptions,
+                plugin: new SlackPlugin(defaultSlackOptions),
             },
-        ],
+        ];
+        const allureReport = new AllureReport(config);
+        await allureReport.start();
+        await allureReport.readDirectory(this.resultsDir);
+        await allureReport.done();
+        const after = new Date().getTime();
+        console.log(`the report successfully generated (${after - before}ms)`);
+    }
+}
+SlackCommand.paths = [["slack"]];
+SlackCommand.usage = Command.Usage({
+    category: "Reports",
+    description: "Posts test results into Slack Channel",
+    details: "This command posts test results from the provided Allure Results directory to a Slack channel.",
+    examples: [
         [
-            "--channel, -c <channel>",
-            {
-                description: "Slack channelId",
-            },
+            "slack ./allure-results --token xoxb-token --channel C12345",
+            "Post test results from the ./allure-results directory to the specified Slack channel",
         ],
     ],
-    action: SlackCommandAction,
 });

package/dist/commands/testplan.d.ts

@@ -1,6 +1,8 @@
-type CommandOptions = {
-    output?: string;
-};
-export declare const TestPlanCommandAction: (resultsDir: string, options: CommandOptions) => Promise<void>;
-export declare const TestPlanCommand: (cli: import("cac").CAC) => void;
-export {};
+import { Command } from "clipanion";
+export declare class TestPlanCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    resultsDir: string;
+    output: string | undefined;
+    execute(): Promise<void>;
+}