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

package/dist/commands/csv.js

@@ -1,75 +1,69 @@
-import { AllureReport, enforcePlugin, readConfig } from "@allurereport/core";
+import { AllureReport, readConfig } from "@allurereport/core";
 import CsvPlugin from "@allurereport/plugin-csv";
+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 CsvCommandAction = async (resultsDir, options) => {
-    const cwd = await realpath(options.cwd ?? process.cwd());
-    const before = new Date().getTime();
-    const { config: configPath, output, knownIssues: knownIssuesPath, separator, disableHeaders } = options;
-    const defaultCsvOptions = {
-        separator,
-        disableHeaders,
-    };
-    const config = enforcePlugin(await readConfig(cwd, configPath, {
-        output,
-        knownIssuesPath,
-    }), {
-        id: "csv",
-        enabled: true,
-        options: defaultCsvOptions,
-        plugin: new CsvPlugin(defaultCsvOptions),
-    });
-    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 CsvCommand = createCommand({
-    name: "csv <resultsDir>",
-    description: "Generates CSV report based on provided Allure Results",
-    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. Absolute paths are accepted as well",
-                default: "allure.csv",
-            },
-        ],
-        [
-            "--disable-headers",
+export class CsvCommand 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.output = Option.String("--output,-o", {
+            description: "The output file name. Absolute paths are accepted as well",
+        });
+        this.disableHeaders = Option.Boolean("--disable-headers", {
+            description: "Specify, to disable CSV headers",
+        });
+        this.separator = Option.String("--separator", {
+            description: "The csv separator",
+        });
+        this.knownIssues = Option.String("--known-issues", {
+            description: "Path to the known issues file. Updates the file and quarantines failed tests when specified",
+        });
+    }
+    async execute() {
+        const cwd = await realpath(this.cwd ?? process.cwd());
+        const before = new Date().getTime();
+        const defaultCsvOptions = {
+            separator: this.separator ?? ",",
+            disableHeaders: this.disableHeaders ?? false,
+        };
+        const config = await readConfig(cwd, this.config, {
+            output: this.output ?? "allure.csv",
+            knownIssuesPath: this.knownIssues,
+        });
+        config.plugins = [
             {
-                description: "Specify, to disable CSV headers",
+                id: "csv",
+                enabled: true,
+                options: defaultCsvOptions,
+                plugin: new CsvPlugin(defaultCsvOptions),
             },
-        ],
-        [
-            "--separator <string>",
-            {
-                description: "The csv separator",
-                default: ",",
-            },
-        ],
+        ];
+        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)`);
+    }
+}
+CsvCommand.paths = [["csv"]];
+CsvCommand.usage = Command.Usage({
+    category: "Reports",
+    description: "Generates CSV report based on provided Allure Results",
+    details: "This command generates a CSV report from the provided Allure Results directory.",
+    examples: [
+        ["csv ./allure-results", "Generate a report from the ./allure-results directory"],
         [
-            "--known-issues <file>",
-            {
-                description: "Path to the known issues file. Updates the file and quarantines failed tests when specified",
-            },
+            "csv ./allure-results --output custom-report.csv",
+            "Generate a report from the ./allure-results directory to the custom-report.csv file",
         ],
     ],
-    action: CsvCommandAction,
 });

package/dist/commands/dashboard.d.ts

@@ -1,13 +1,15 @@
-type DashboardCommandOptions = {
-    cwd?: string;
-    config?: string;
-    output?: string;
-    reportName?: string;
-    reportLanguage?: string;
-    logo?: string;
-    singleFile?: boolean;
-    theme?: "light" | "dark";
-};
-export declare const DashboardCommandAction: (resultsDir: string, options: DashboardCommandOptions) => Promise<void>;
-export declare const DashboardCommand: (cli: import("cac").CAC) => void;
-export {};
+import { Command } from "clipanion";
+export declare class DashboardCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    resultsDir: string;
+    config: string | undefined;
+    cwd: string | undefined;
+    output: string | undefined;
+    reportName: string | undefined;
+    singleFile: boolean | undefined;
+    logo: string | undefined;
+    theme: string | undefined;
+    reportLanguage: string | undefined;
+    execute(): Promise<void>;
+}

package/dist/commands/dashboard.js

@@ -1,88 +1,77 @@
-import { AllureReport, enforcePlugin, readConfig } from "@allurereport/core";
+import { AllureReport, readConfig } from "@allurereport/core";
 import DashboardPlugin from "@allurereport/plugin-dashboard";
+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 DashboardCommandAction = async (resultsDir, options) => {
-    const cwd = await realpath(options.cwd ?? process.cwd());
-    const before = new Date().getTime();
-    const { config: configPath, output, reportName: name, ...rest } = options;
-    const defaultDashboardOptions = {
-        ...rest,
-        reportLanguage: rest.reportLanguage ?? "en",
-    };
-    const config = enforcePlugin(await readConfig(cwd, configPath, {
-        output,
-        name,
-    }), {
-        id: "dashboard",
-        enabled: true,
-        options: defaultDashboardOptions,
-        plugin: new DashboardPlugin(defaultDashboardOptions),
-    });
-    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 DashboardCommand = createCommand({
-    name: "dashboard <resultsDir>",
-    description: "Generates Allure Dashboard report based on provided Allure Results",
-    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 directory name. Absolute paths are accepted as well",
-                default: "allure-report",
-            },
-        ],
-        [
-            "--report-name, --name <string>",
-            {
-                description: "The report name",
-                default: "Allure Report",
-            },
-        ],
-        [
-            "--single-file",
-            {
-                description: "Generate single file report",
-                default: false,
-            },
-        ],
-        [
-            "--logo <string>",
+export class DashboardCommand 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.output = Option.String("--output,-o", {
+            description: "The output directory name. Absolute paths are accepted as well",
+        });
+        this.reportName = Option.String("--report-name,--name", {
+            description: "The report name",
+        });
+        this.singleFile = Option.Boolean("--single-file", {
+            description: "Generate single file report",
+        });
+        this.logo = Option.String("--logo", {
+            description: "Path to the report logo which will be displayed in the header",
+        });
+        this.theme = Option.String("--theme", {
+            description: "Default theme of the report (default: OS theme)",
+        });
+        this.reportLanguage = Option.String("--report-language,--lang", {
+            description: "Default language of the report (default: OS language)",
+        });
+    }
+    async execute() {
+        const cwd = await realpath(this.cwd ?? process.cwd());
+        const before = new Date().getTime();
+        const defaultDashboardOptions = {
+            singleFile: this.singleFile ?? false,
+            logo: this.logo,
+            theme: this.theme,
+            reportLanguage: this.reportLanguage ?? "en",
+        };
+        const config = await readConfig(cwd, this.config, {
+            output: this.output ?? "allure-report",
+            name: this.reportName ?? "Allure Report",
+        });
+        config.plugins = [
             {
-                description: "Path to the report logo which will be displayed in the header",
+                id: "dashboard",
+                enabled: true,
+                options: defaultDashboardOptions,
+                plugin: new DashboardPlugin(defaultDashboardOptions),
             },
-        ],
-        [
-            "--theme <string>",
-            {
-                description: "Default theme of the report (default: OS theme)",
-            },
-        ],
+        ];
+        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)`);
+    }
+}
+DashboardCommand.paths = [["dashboard"]];
+DashboardCommand.usage = Command.Usage({
+    category: "Reports",
+    description: "Generates Allure Dashboard report based on provided Allure Results",
+    details: "This command generates an Allure Dashboard report from the provided Allure Results directory.",
+    examples: [
+        ["dashboard ./allure-results", "Generate a report from the ./allure-results directory"],
         [
-            "--report-language, --lang <string>",
-            {
-                description: "Default language of the report (default: OS language)",
-            },
+            "dashboard ./allure-results --output custom-report",
+            "Generate a report from the ./allure-results directory to the custom-report directory",
         ],
     ],
-    action: DashboardCommandAction,
 });

package/dist/commands/generate.d.ts

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

package/dist/commands/generate.js

@@ -1,49 +1,57 @@
 import { AllureReport, readConfig } from "@allurereport/core";
 import { KnownError } from "@allurereport/service";
+import { Command, Option } from "clipanion";
+import process from "node:process";
 import { red } from "yoctocolors";
-import { createCommand } from "../utils/commands.js";
 import { logError } from "../utils/logs.js";
-export const GenerateCommandAction = async (resultsDir, options) => {
-    const { config: configPath, output, cwd, reportName } = options;
-    const config = await readConfig(cwd, configPath, { name: reportName, output });
-    try {
-        const allureReport = new AllureReport(config);
-        await allureReport.start();
-        await allureReport.readDirectory(resultsDir);
-        await allureReport.done();
+export class GenerateCommand 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.output = Option.String("--output,-o", {
+            description: "The output directory name. Absolute paths are accepted as well (default: allure-report)",
+        });
+        this.cwd = Option.String("--cwd", {
+            description: "The working directory for the command to run (default: current working directory)",
+        });
+        this.reportName = Option.String("--report-name,--name", {
+            description: "The report name",
+        });
     }
-    catch (error) {
-        if (error instanceof KnownError) {
-            console.error(red(error.message));
+    async execute() {
+        const config = await readConfig(this.cwd, this.config, {
+            name: this.reportName,
+            output: this.output ?? "allure-report",
+        });
+        try {
+            const allureReport = new AllureReport(config);
+            await allureReport.start();
+            await allureReport.readDirectory(this.resultsDir);
+            await allureReport.done();
+        }
+        catch (error) {
+            if (error instanceof KnownError) {
+                console.error(red(error.message));
+                process.exit(1);
+                return;
+            }
+            await logError("Failed to generate report due to unexpected error", error);
             process.exit(1);
-            return;
         }
-        await logError("Failed to generate report due to unexpected error", error);
-        process.exit(1);
     }
-};
-export const GenerateCommand = createCommand({
-    name: "generate <resultsDir>",
+}
+GenerateCommand.paths = [["generate"]];
+GenerateCommand.usage = Command.Usage({
     description: "Generates the report to specified directory",
-    options: [
-        [
-            "--config, -c <file>",
-            {
-                description: "The path Allure config file",
-            },
-        ],
-        [
-            "--output, -o <file>",
-            {
-                description: "The output directory name. Absolute paths are accepted as well (default: allure-report)",
-            },
-        ],
+    details: "This command generates a report from the provided Allure Results directory.",
+    examples: [
+        ["generate ./allure-results", "Generate a report from the ./allure-results directory"],
         [
-            "--cwd <cwd>",
-            {
-                description: "The working directory for the command to run (default: current working directory)",
-            },
+            "generate ./allure-results --output custom-report",
+            "Generate a report from the ./allure-results directory to the custom-report directory",
         ],
     ],
-    action: GenerateCommandAction,
 });

package/dist/commands/history.d.ts

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

package/dist/commands/history.js

@@ -1,34 +1,37 @@
 import { AllureReport, resolveConfig } from "@allurereport/core";
-import { createCommand } from "../utils/commands.js";
-export const HistoryCommandAction = async (resultsDir, options) => {
-    const config = await resolveConfig({
-        historyPath: options.historyPath,
-        name: options.reportName,
-        plugins: {},
-    });
-    const allureReport = new AllureReport(config);
-    await allureReport.start();
-    await allureReport.readDirectory(resultsDir);
-    await allureReport.done();
-};
-export const HistoryCommand = createCommand({
-    name: "history <resultsDir>",
+import { Command, Option } from "clipanion";
+export class HistoryCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.resultsDir = Option.String({ required: true, name: "The directory with Allure results" });
+        this.historyPath = Option.String("--history-path,-h", {
+            description: "The path to history file",
+        });
+        this.reportName = Option.String("--report-name,--name", {
+            description: "The report name",
+        });
+    }
+    async execute() {
+        const config = await resolveConfig({
+            historyPath: this.historyPath ?? "history.jsonl",
+            name: this.reportName ?? "Allure Report",
+            plugins: {},
+        });
+        const allureReport = new AllureReport(config);
+        await allureReport.start();
+        await allureReport.readDirectory(this.resultsDir);
+        await allureReport.done();
+    }
+}
+HistoryCommand.paths = [["history"]];
+HistoryCommand.usage = Command.Usage({
     description: "Generates the history to specified folder",
-    options: [
+    details: "This command generates history from the provided Allure Results directory.",
+    examples: [
+        ["history ./allure-results", "Generate history from the ./allure-results directory"],
         [
-            "--history-path, -h <file>",
-            {
-                description: "The path to history file",
-                default: "history.jsonl",
-            },
-        ],
-        [
-            "--report-name, --name <string>",
-            {
-                description: "The report name",
-                default: "Allure Report",
-            },
+            "history ./allure-results --history-path custom-history.jsonl",
+            "Generate history from the ./allure-results directory to the custom-history.jsonl file",
         ],
     ],
-    action: HistoryCommandAction,
 });

package/dist/commands/knownIssue.d.ts

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

package/dist/commands/knownIssue.js

@@ -1,31 +1,38 @@
 import { AllureReport, resolveConfig, writeKnownIssues } from "@allurereport/core";
+import { Command, Option } from "clipanion";
 import console from "node:console";
 import { resolve } from "node:path";
-import { createCommand } from "../utils/commands.js";
-export const KnownIssueCommandAction = async (resultsDir, options) => {
-    const { output = "known-issues.json" } = options;
-    const config = await resolveConfig({
-        plugins: {},
-    });
-    const allureReport = new AllureReport(config);
-    await allureReport.start();
-    await allureReport.readDirectory(resultsDir);
-    await allureReport.done();
-    const targetPath = resolve(output);
-    await writeKnownIssues(allureReport.store, output);
-    console.log(`writing known-issues.json to ${targetPath}`);
-};
-export const KnownIssueCommand = createCommand({
-    name: "known-issue <resultsDir>",
+export class KnownIssueCommand 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 outputPath = this.output ?? "known-issues.json";
+        const config = await resolveConfig({
+            plugins: {},
+        });
+        const allureReport = new AllureReport(config);
+        await allureReport.start();
+        await allureReport.readDirectory(this.resultsDir);
+        await allureReport.done();
+        const targetPath = resolve(outputPath);
+        await writeKnownIssues(allureReport.store, outputPath);
+        console.log(`writing known-issues.json to ${targetPath}`);
+    }
+}
+KnownIssueCommand.paths = [["known-issue"]];
+KnownIssueCommand.usage = Command.Usage({
     description: "Generates a known issue list",
-    options: [
+    details: "This command generates a known issue list from the provided Allure Results directory.",
+    examples: [
+        ["known-issue ./allure-results", "Generate a known issue list from the ./allure-results directory"],
         [
-            "--output, -o <file>",
-            {
-                description: "The output file name. Absolute paths are accepted as well",
-                default: "known-issues.json",
-            },
+            "known-issue ./allure-results --output custom-issues.json",
+            "Generate a known issue list from the ./allure-results directory to the custom-issues.json file",
         ],
     ],
-    action: KnownIssueCommandAction,
 });

package/dist/commands/log.d.ts

@@ -1,9 +1,12 @@
-export type LogCommandOptions = {
-    cwd?: string;
-    config?: string;
-    allSteps?: boolean;
-    withTrace?: boolean;
-    groupBy?: "suites" | "features" | "packages" | "none";
-};
-export declare const LogCommandAction: (resultsDir: string, options: LogCommandOptions) => Promise<void>;
-export declare const LogCommand: (cli: import("cac").CAC) => void;
+import { Command } from "clipanion";
+export declare class LogCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    resultsDir: string;
+    config: string | undefined;
+    cwd: string | undefined;
+    groupBy: string | undefined;
+    allSteps: boolean | undefined;
+    withTrace: boolean | undefined;
+    execute(): Promise<void>;
+}