allure 3.0.0-beta.2 → 3.0.0-beta.20

package/dist/commands/run.js

@@ -1,16 +1,21 @@
-import { AllureReport, isFileNotFoundError, readRuntimeConfig } from "@allure/core";
-import { createTestPlan } from "@allure/core-api";
-import { allureResultsDirectoriesWatcher, delayedFileProcessingWatcher, newFilesInDirectoryWatcher, } from "@allure/directory-watcher";
-import AllureAwesome from "@allure/plugin-awesome";
-import { PathResultFile } from "@allure/reader-api";
+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 { 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 { createCommand } from "../utils/commands.js";
+import process, { exit } from "node:process";
+import terminate from "terminate/promise";
+import { red } from "yoctocolors";
 import { logTests, runProcess, terminationOf } from "../utils/index.js";
-const runTests = async (allureReport, cwd, command, commandArgs, environment, silent) => {
+import { logError } from "../utils/logs.js";
+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) => {
@@ -44,124 +49,289 @@ 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();
+    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", (code) => {
-        const after = new Date().getTime();
-        console.log(`exit code ${code} (${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 readRuntimeConfig(configPath, cwd, output, 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.stage = Option.String("--stage", {
+            description: "Runs tests in stage mode to collect results to a stage archive with the provided name (default: empty string)",
+        });
+        this.environment = Option.String("--environment", {
+            description: "Force specific environment to all tests in the run. Given environment has higher priority than the one defined in the config file (default: empty string)",
+        });
+        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";
     }
-    const allureReport = new AllureReport({
-        ...config,
-        realTime: false,
-        plugins: [
-            ...(config.plugins?.length
-                ? config.plugins
-                : [
-                    {
-                        id: "awesome",
-                        enabled: true,
-                        options: {},
-                        plugin: new AllureAwesome({
-                            reportName: config.name,
-                        }),
+    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,
+            environment: this.environment,
+            stage: this.stage,
+            realTime: false,
+            plugins: [
+                ...(config.plugins?.length
+                    ? config.plugins
+                    : [
+                        {
+                            id: "awesome",
+                            enabled: true,
+                            options: {},
+                            plugin: new Awesome({
+                                reportName: config.name,
+                            }),
+                        },
+                    ]),
+            ],
+        });
+        const knownIssues = await allureReport.store.allKnownIssues();
+        await allureReport.start();
+        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}`,
                     },
-                ]),
-        ],
-    });
-    await allureReport.start();
-    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;
+                    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;
+            }
         }
-        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));
-        await runTests(allureReport, cwd, command, commandArgs, {
-            ALLURE_TESTPLAN_PATH: testPlanPath,
-            ALLURE_RERUN: `${rerun}`,
-        }, silent);
-        await rm(tmpDir, { recursive: true });
-        logTests(await allureReport.store.allTestResults());
+        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,
+                });
+            }
+        }
+        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);
     }
-    await allureReport.done();
-    await allureReport.validate();
-    process.exit(allureReport.exitCode);
-};
-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)",
-            },
-        ],
+    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"],
         [
-            "--silent",
-            {
-                description: "Don't pipe the process output logs to console (Default: 0)",
-            },
+            "run --stage=my-stage -- npm run test",
+            "Run npm run test and pack inner report state into my-stage.zip archive to restore the state in the next run",
         ],
     ],
-    action: RunCommandAction,
 });

package/dist/commands/slack.d.ts

@@ -1,7 +1,11 @@
-type CommandOptions = {
+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,37 +1,61 @@
-import { AllureReport, resolveConfig } from "@allure/core";
-import { createCommand } from "../utils/commands.js";
-export const SlackCommandAction = async (resultsDir, options) => {
-    const before = new Date().getTime();
-    const config = await resolveConfig({
-        plugins: {
-            "@allure/plugin-slack": {
-                options,
-            },
-        },
-    });
-    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: [
-        [
-            "--token, -t <token>",
+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";
+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>;
+}

package/dist/commands/testplan.js

@@ -1,37 +1,45 @@
-import { AllureReport, resolveConfig } from "@allure/core";
+import { AllureReport, resolveConfig } from "@allurereport/core";
+import { Command, Option } from "clipanion";
+import * as console from "node:console";
 import { basename, dirname, resolve } from "node:path";
-import { createCommand } from "../utils/commands.js";
-export const TestPlanCommandAction = async (resultsDir, options) => {
-    const before = new Date().getTime();
-    const resolved = resolve(options.output ?? "./testplan.json");
-    const output = dirname(resolved);
-    const fileName = basename(resolved);
-    const config = await resolveConfig({
-        output: output,
-        plugins: {
-            "@allure/plugin-testplan": {
-                options: { fileName },
+export class TestPlanCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.resultsDir = Option.String({ required: true, name: "The directory with Allure results" });
+        this.output = Option.String("--output,-o", {
+            description: "The output file name. Absolute paths are accepted as well",
+        });
+    }
+    async execute() {
+        const before = new Date().getTime();
+        const resolved = resolve(this.output ?? "./testplan.json");
+        const output = dirname(resolved);
+        const fileName = basename(resolved);
+        const config = await resolveConfig({
+            output: output,
+            plugins: {
+                "@allurereport/plugin-testplan": {
+                    options: { fileName },
+                },
             },
-        },
-    });
-    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 TestPlanCommand = createCommand({
-    name: "testplan <resultsDir>",
+        });
+        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)`);
+    }
+}
+TestPlanCommand.paths = [["testplan"]];
+TestPlanCommand.usage = Command.Usage({
     description: "Generates testplan.json based on provided Allure Results",
-    options: [
+    details: "This command generates a testplan.json file from the provided Allure Results directory.",
+    examples: [
+        ["testplan ./allure-results", "Generate a testplan.json file from the ./allure-results directory"],
         [
-            "--output, -o <file>",
-            {
-                description: "The output file name. Absolute paths are accepted as well",
-                default: "testplan.json",
-            },
+            "testplan ./allure-results --output custom-testplan.json",
+            "Generate a custom-testplan.json file from the ./allure-results directory",
         ],
     ],
-    action: TestPlanCommandAction,
 });

package/dist/commands/watch.d.ts

@@ -1,10 +1,12 @@
-type WatchCommandOptions = {
-    config?: string;
-    output?: string;
-    cwd?: string;
-    reportName?: string;
-    port?: string;
-};
-export declare const WatchCommandAction: (resultsDir: string, options: WatchCommandOptions) => Promise<void>;
-export declare const WatchCommand: (cli: import("cac").CAC) => void;
-export {};
+import { Command } from "clipanion";
+export declare class WatchCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    resultsDir: string;
+    config: string | undefined;
+    cwd: string | undefined;
+    output: string | undefined;
+    reportName: string | undefined;
+    port: string | undefined;
+    execute(): Promise<void>;
+}