allure 3.0.0-beta.16 → 3.0.0-beta.17

package/dist/commands/run.js

@@ -4,13 +4,13 @@ import { allureResultsDirectoriesWatcher, delayedFileProcessingWatcher, newFiles
 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 { 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) => {
@@ -59,124 +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");
-    }
-    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.commandToRun = Option.Proxy();
     }
-    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");
         }
-    }
-    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,
-                            }),
-                        },
-                    ]),
-            ],
+        const before = new Date().getTime();
+        process.on("exit", (exitCode) => {
+            const after = new Date().getTime();
+            console.log(`exit code ${exitCode} (${after - before}ms)`);
         });
-        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 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);
             }
-            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));
+        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);
-            return;
         }
-        await logError("Failed to run tests using Allure due to unexpected error", error);
-        process.exit(1);
     }
-};
-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>;
+}

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>;
+}