allure 3.0.0-beta.15 → 3.0.0-beta.17

package/dist/commands/qualityGate.js

@@ -1,52 +1,56 @@
 import { AllureReport, readConfig } from "@allurereport/core";
-import console from "node:console";
-import process from "node:process";
+import { Command, Option } from "clipanion";
+import * as console from "node:console";
+import { exit } from "node:process";
 import { bold, red } from "yoctocolors";
-import { createCommand } from "../utils/commands.js";
-export const QualityGateCommandAction = async (resultsDir, options) => {
-    const { cwd, config: configPath } = options;
-    const fullConfig = await readConfig(cwd, configPath);
-    const allureReport = new AllureReport(fullConfig);
-    await allureReport.start();
-    await allureReport.readDirectory(resultsDir);
-    await allureReport.done();
-    await allureReport.validate();
-    if (allureReport.exitCode === 0) {
-        return;
+export class QualityGateCommand 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)",
+        });
     }
-    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;
+    async execute() {
+        const fullConfig = await readConfig(this.cwd, this.config);
+        const allureReport = new AllureReport(fullConfig);
+        await allureReport.start();
+        await allureReport.readDirectory(this.resultsDir);
+        await allureReport.done();
+        await allureReport.validate();
+        if (allureReport.exitCode === 0) {
+            return;
         }
-        console.error(red(`⨯ ${bold(`${result.rule}${scope}`)}: expected ${result.expected}, actual ${result.actual}`));
+        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}`));
+        }
+        console.error(red("\nThe process has been exited with code 1"));
+        exit(allureReport.exitCode);
     }
-    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: [
-        [
-            "--config, -c <file>",
-            {
-                description: "The path Allure config file",
-            },
-        ],
+    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/run.d.ts

@@ -1,10 +1,13 @@
-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 { Command } from "clipanion";
+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;
+    commandToRun: string[];
+    execute(): Promise<void>;
+}

package/dist/commands/run.js

@@ -3,13 +3,16 @@ 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 { 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 { red } from "yoctocolors";
 import { logTests, runProcess, terminationOf } from "../utils/index.js";
+import { logError } from "../utils/logs.js";
 const runTests = async (allureReport, cwd, command, commandArgs, environment, silent) => {
     let testProcessStarted = false;
     const allureResultsWatchers = new Map();
@@ -56,113 +59,115 @@ const runTests = async (allureReport, cwd, command, commandArgs, environment, si
     await processWatcher.abort();
     return code;
 };
-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");
+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.commandToRun = Option.Proxy();
     }
-    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 });
-    }
-    catch (e) {
-        if (!isFileNotFoundError(e)) {
-            console.error("could not clean output directory", e);
+    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 allureReport = new AllureReport({
-        ...config,
-        realTime: false,
-        plugins: [
-            ...(config.plugins?.length
-                ? config.plugins
-                : [
-                    {
-                        id: "awesome",
-                        enabled: true,
-                        options: {},
-                        plugin: new Awesome({
-                            reportName: config.name,
-                        }),
-                    },
-                ]),
-        ],
-    });
-    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 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 silent = this.silent ?? false;
+        const config = await readConfig(cwd, this.config, { output: this.output, name: this.reportName });
+        try {
+            await rm(config.output, { recursive: true });
+        }
+        catch (e) {
+            if (!isFileNotFoundError(e)) {
+                console.error("could not clean output directory", e);
+            }
+        }
+        try {
+            const allureReport = new AllureReport({
+                ...config,
+                realTime: false,
+                plugins: [
+                    ...(config.plugins?.length
+                        ? config.plugins
+                        : [
+                            {
+                                id: "awesome",
+                                enabled: true,
+                                options: {},
+                                plugin: new Awesome({
+                                    reportName: config.name,
+                                }),
+                            },
+                        ]),
+                ],
+            });
+            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());
+            }
+            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;
+            }
+            await logError("Failed to run tests using Allure due to unexpected error", error);
+            process.exit(1);
         }
-        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());
     }
-    await allureReport.done();
-    await allureReport.validate();
-    process.exit(code ?? 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)",
-            },
-        ],
-        [
-            "--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,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,38 +1,61 @@
-import { AllureReport, resolveConfig } 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 { createCommand } from "../utils/commands.js";
-export const SlackCommandAction = async (resultsDir, options) => {
-    const before = new Date().getTime();
-    const config = await resolveConfig({
-        plugins: {
-            "@allurereport/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 { 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,38 +1,45 @@
 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: {
-            "@allurereport/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>;
+}