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

package/dist/commands/allure2.d.ts

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

package/dist/commands/allure2.js

@@ -1,89 +1,77 @@
-import { AllureReport, enforcePlugin, readConfig } from "@allurereport/core";
+import { AllureReport, readConfig } from "@allurereport/core";
 import Allure2Plugin from "@allurereport/plugin-allure2";
+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 ClassicLegacyCommandAction = async (resultsDir, options) => {
-    const cwd = await realpath(options.cwd ?? process.cwd());
-    const before = new Date().getTime();
-    const { config: configPath, output, reportName, historyPath, knownIssues: knownIssuesPath, ...rest } = options;
-    const defaultAllure2Options = {
-        ...rest,
-    };
-    const config = enforcePlugin(await readConfig(cwd, configPath, {
-        output,
-        name: reportName,
-        knownIssuesPath,
-        historyPath,
-    }), {
-        id: "allure2",
-        enabled: true,
-        options: defaultAllure2Options,
-        plugin: new Allure2Plugin(defaultAllure2Options),
-    });
-    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 ClassicLegacyCommand = createCommand({
-    name: "allure2 <resultsDir>",
-    description: "Generates Allure Classic 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",
-            },
-        ],
-        [
-            "--report-language, --lang <string>",
-            {
-                description: "Default language of the report (default: OS language)",
-            },
-        ],
-        [
-            "--single-file",
+export class Allure2Command 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.reportLanguage = Option.String("--report-language,--lang", {
+            description: "Default language of the report (default: OS language)",
+        });
+        this.singleFile = Option.Boolean("--single-file", {
+            description: "Generate single file report",
+        });
+        this.historyPath = Option.String("--history-path,-h", {
+            description: "The path to history file",
+        });
+        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 defaultAllure2Options = {
+            singleFile: this.singleFile ?? false,
+            reportLanguage: this.reportLanguage,
+        };
+        const config = await readConfig(cwd, this.config, {
+            output: this.output ?? "allure-report",
+            name: this.reportName ?? "Allure Report",
+            knownIssuesPath: this.knownIssues,
+            historyPath: this.historyPath,
+        });
+        config.plugins = [
             {
-                description: "Generate single file report",
-                default: false,
+                id: "allure2",
+                enabled: true,
+                options: defaultAllure2Options,
+                plugin: new Allure2Plugin(defaultAllure2Options),
             },
-        ],
-        [
-            "--history-path, -h <file>",
-            {
-                description: "The path to history file",
-            },
-        ],
+        ];
+        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)`);
+    }
+}
+Allure2Command.paths = [["allure2"]];
+Allure2Command.usage = Command.Usage({
+    category: "Reports",
+    description: "Generates Allure Classic report based on provided Allure Results",
+    details: "This command generates an Allure Classic report from the provided Allure Results directory.",
+    examples: [
+        ["allure2 ./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",
-            },
+            "allure2 ./allure-results --output custom-report",
+            "Generate a report from the ./allure-results directory to the custom-report directory",
         ],
     ],
-    action: ClassicLegacyCommandAction,
 });

package/dist/commands/awesome.d.ts

@@ -1,15 +1,18 @@
-type AwesomeCommandOptions = {
-    cwd?: string;
-    config?: string;
-    output?: string;
-    reportName?: string;
-    reportLanguage?: string;
-    logo?: string;
-    singleFile?: boolean;
-    historyPath?: string;
-    knownIssues?: string;
-    groupBy?: string;
-};
-export declare const AwesomeCommandAction: (resultsDir: string, options: AwesomeCommandOptions) => Promise<void>;
-export declare const AwesomeCommand: (cli: import("cac").CAC) => void;
-export {};
+import { Command } from "clipanion";
+export declare class AwesomeCommand 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;
+    historyPath: string | undefined;
+    knownIssues: string | undefined;
+    groupBy: string | undefined;
+    execute(): Promise<void>;
+}

package/dist/commands/awesome.js

@@ -1,109 +1,89 @@
-import { AllureReport, enforcePlugin, readConfig } from "@allurereport/core";
+import { AllureReport, readConfig } from "@allurereport/core";
 import { default as AwesomePlugin } from "@allurereport/plugin-awesome";
+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 AwesomeCommandAction = async (resultsDir, options) => {
-    const cwd = await realpath(options.cwd ?? process.cwd());
-    const before = new Date().getTime();
-    const { config: configPath, output, reportName, historyPath, knownIssues: knownIssuesPath, groupBy, ...rest } = options;
-    const defaultAwesomeOptions = {
-        ...rest,
-        groupBy: groupBy?.split(","),
-    };
-    const config = enforcePlugin(await readConfig(cwd, configPath, {
-        output,
-        name: reportName,
-        knownIssuesPath,
-        historyPath,
-    }), {
-        id: "awesome",
-        enabled: true,
-        options: defaultAwesomeOptions,
-        plugin: new AwesomePlugin(defaultAwesomeOptions),
-    });
-    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 AwesomeCommand = createCommand({
-    name: "awesome <resultsDir>",
-    description: "Generates Allure Awesome 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>",
-            {
-                description: "Path to the report logo which will be displayed in the header",
-            },
-        ],
-        [
-            "--theme <string>",
+export class AwesomeCommand 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)",
+        });
+        this.historyPath = Option.String("--history-path,-h", {
+            description: "The path to history file",
+        });
+        this.knownIssues = Option.String("--known-issues", {
+            description: "Path to the known issues file. Updates the file and quarantines failed tests when specified",
+        });
+        this.groupBy = Option.String("--group-by,-g", {
+            description: "Group test results by labels. The labels should be separated by commas",
+        });
+    }
+    async execute() {
+        const cwd = await realpath(this.cwd ?? process.cwd());
+        const before = new Date().getTime();
+        const defaultAwesomeOptions = {
+            singleFile: this.singleFile ?? false,
+            logo: this.logo,
+            theme: this.theme,
+            reportLanguage: this.reportLanguage,
+            groupBy: this.groupBy?.split?.(",") ?? ["parentSuite", "suite", "subSuite"],
+        };
+        const config = await readConfig(cwd, this.config, {
+            output: this.output ?? "allure-report",
+            name: this.reportName ?? "Allure Report",
+            knownIssuesPath: this.knownIssues,
+            historyPath: this.historyPath,
+        });
+        config.plugins = [
             {
-                description: "Default theme of the report (default: OS theme)",
+                id: "awesome",
+                enabled: true,
+                options: defaultAwesomeOptions,
+                plugin: new AwesomePlugin(defaultAwesomeOptions),
             },
-        ],
-        [
-            "--report-language, --lang <string>",
-            {
-                description: "Default language of the report (default: OS language)",
-            },
-        ],
-        [
-            "--history-path, -h <file>",
-            {
-                description: "The path to history file",
-            },
-        ],
-        [
-            "--known-issues <file>",
-            {
-                description: "Path to the known issues file. Updates the file and quarantines failed tests when specified",
-            },
-        ],
+        ];
+        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)`);
+    }
+}
+AwesomeCommand.paths = [["awesome"]];
+AwesomeCommand.usage = Command.Usage({
+    category: "Reports",
+    description: "Generates Allure Awesome report based on provided Allure Results",
+    details: "This command generates an Allure Awesome report from the provided Allure Results directory.",
+    examples: [
+        ["awesome ./allure-results", "Generate a report from the ./allure-results directory"],
         [
-            "--group-by, -g <string>",
-            {
-                description: "Group test results by labels. The labels should be separated by commas",
-                default: "parentSuite,suite,subSuite",
-            },
+            "awesome ./allure-results --output custom-report",
+            "Generate a report from the ./allure-results directory to the custom-report directory",
         ],
     ],
-    action: AwesomeCommandAction,
 });

package/dist/commands/classic.d.ts

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

package/dist/commands/classic.js

@@ -1,89 +1,77 @@
-import { AllureReport, enforcePlugin, readConfig } from "@allurereport/core";
+import { AllureReport, readConfig } from "@allurereport/core";
 import ClassicPlugin from "@allurereport/plugin-classic";
+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 ClassicCommandAction = async (resultsDir, options) => {
-    const cwd = await realpath(options.cwd ?? process.cwd());
-    const before = new Date().getTime();
-    const { config: configPath, output, reportName: name, historyPath, knownIssues: knownIssuesPath, ...rest } = options;
-    const defaultClassicOptions = {
-        ...rest,
-    };
-    const config = enforcePlugin(await readConfig(cwd, configPath, {
-        output,
-        name,
-        historyPath,
-        knownIssuesPath,
-    }), {
-        id: "classic",
-        enabled: true,
-        options: defaultClassicOptions,
-        plugin: new ClassicPlugin(defaultClassicOptions),
-    });
-    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 ClassicCommand = createCommand({
-    name: "classic <resultsDir>",
-    description: "Generates Allure Classic 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",
-            },
-        ],
-        [
-            "--report-language, --lang <string>",
-            {
-                description: "Default language of the report (default: OS language)",
-            },
-        ],
-        [
-            "--single-file",
+export class ClassicCommand 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.reportLanguage = Option.String("--report-language,--lang", {
+            description: "Default language of the report (default: OS language)",
+        });
+        this.singleFile = Option.Boolean("--single-file", {
+            description: "Generate single file report",
+        });
+        this.historyPath = Option.String("--history-path,-h", {
+            description: "The path to history file",
+        });
+        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 defaultClassicOptions = {
+            singleFile: this.singleFile ?? false,
+            reportLanguage: this.reportLanguage,
+        };
+        const config = await readConfig(cwd, this.config, {
+            output: this.output ?? "allure-report",
+            name: this.reportName ?? "Allure Report",
+            knownIssuesPath: this.knownIssues,
+            historyPath: this.historyPath,
+        });
+        config.plugins = [
             {
-                description: "Generate single file report",
-                default: false,
+                id: "classic",
+                enabled: true,
+                options: defaultClassicOptions,
+                plugin: new ClassicPlugin(defaultClassicOptions),
             },
-        ],
-        [
-            "--history-path, -h <file>",
-            {
-                description: "The path to history file",
-            },
-        ],
+        ];
+        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)`);
+    }
+}
+ClassicCommand.paths = [["classic"]];
+ClassicCommand.usage = Command.Usage({
+    category: "Reports",
+    description: "Generates Allure Classic report based on provided Allure Results",
+    details: "This command generates an Allure Classic report from the provided Allure Results directory.",
+    examples: [
+        ["classic ./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",
-            },
+            "classic ./allure-results --output custom-report",
+            "Generate a report from the ./allure-results directory to the custom-report directory",
         ],
     ],
-    action: ClassicCommandAction,
 });

package/dist/commands/csv.d.ts

@@ -1,11 +1,13 @@
-type CsvCommandOptions = {
-    cwd?: string;
-    config?: string;
-    separator?: string;
-    disableHeaders?: boolean;
-    output?: string;
-    knownIssues?: string;
-};
-export declare const CsvCommandAction: (resultsDir: string, options: CsvCommandOptions) => Promise<void>;
-export declare const CsvCommand: (cli: import("cac").CAC) => void;
-export {};
+import { Command } from "clipanion";
+export declare class CsvCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    resultsDir: string;
+    config: string | undefined;
+    cwd: string | undefined;
+    output: string | undefined;
+    disableHeaders: boolean | undefined;
+    separator: string | undefined;
+    knownIssues: string | undefined;
+    execute(): Promise<void>;
+}