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

package/dist/commands/csv.d.ts

@@ -1,9 +1,13 @@
-type CsvCommandOptions = {
-    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>;
+}

package/dist/commands/csv.js

@@ -1,51 +1,69 @@
-import { AllureReport, resolveConfig } from "@allure/core";
-import { createCommand } from "../utils/commands.js";
-export const CsvCommandAction = async (resultsDir, options) => {
-    const before = new Date().getTime();
-    const config = await resolveConfig({
-        plugins: {
-            "@allure/plugin-csv": {
-                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 CsvCommand = createCommand({
-    name: "csv <resultsDir>",
-    description: "Generates CSV report based on provided Allure Results",
-    options: [
-        [
-            "--output, -o <file>",
-            {
-                description: "The output file name. Absolute paths are accepted as well",
-                default: "allure.csv",
-            },
-        ],
-        [
-            "--disable-headers",
+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";
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,77 @@
+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";
+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 = [
+            {
+                id: "dashboard",
+                enabled: true,
+                options: defaultDashboardOptions,
+                plugin: new DashboardPlugin(defaultDashboardOptions),
+            },
+        ];
+        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"],
+        [
+            "dashboard ./allure-results --output custom-report",
+            "Generate a report from the ./allure-results directory to the custom-report directory",
+        ],
+    ],
+});

package/dist/commands/generate.d.ts

@@ -1,9 +1,12 @@
-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 | undefined;
+    config: string | undefined;
+    output: string | undefined;
+    cwd: string | undefined;
+    reportName: string | undefined;
+    stage: string[] | undefined;
+    execute(): Promise<void>;
+}

package/dist/commands/generate.js

@@ -1,35 +1,108 @@
-import { AllureReport, readRuntimeConfig } from "@allure/core";
-import { createCommand } from "../utils/commands.js";
-export const GenerateCommandAction = async (resultsDir, options) => {
-    const { config: configPath, output, cwd, reportName } = options;
-    const config = await readRuntimeConfig(configPath, cwd, output, reportName);
-    const allureReport = new AllureReport(config);
-    await allureReport.start();
-    await allureReport.readDirectory(resultsDir);
-    await allureReport.done();
-};
-export const GenerateCommand = createCommand({
-    name: "generate <resultsDir>",
+import { AllureReport, readConfig } from "@allurereport/core";
+import { KnownError } from "@allurereport/service";
+import { Command, Option } from "clipanion";
+import { glob } from "glob";
+import * as console from "node:console";
+import { sep } from "node:path";
+import { exit, cwd as processCwd } from "node:process";
+import { red } from "yoctocolors";
+import { logError } from "../utils/logs.js";
+export class GenerateCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.resultsDir = Option.String({
+            required: false,
+            name: "Pattern to match test results directories in the current working directory (default: ./**/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 (default: Allure Report)",
+        });
+        this.stage = Option.Array("--stage", {
+            description: "Stages archives to restore state from (default: empty string)",
+        });
+    }
+    async execute() {
+        const cwd = this.cwd ?? processCwd();
+        const resultsDir = (this.resultsDir ?? "./**/allure-results").replace(/[\\/]$/, "");
+        const config = await readConfig(cwd, this.config, {
+            name: this.reportName,
+            output: this.output ?? "allure-report",
+        });
+        const stageDumpFiles = [];
+        const resultsDirectories = [];
+        if (this.stage?.length) {
+            for (const stage of this.stage) {
+                const matchedFiles = await glob(stage, {
+                    nodir: true,
+                    dot: true,
+                    absolute: true,
+                    windowsPathsNoEscape: true,
+                    cwd,
+                });
+                stageDumpFiles.push(...matchedFiles);
+            }
+        }
+        if (!!this.resultsDir || stageDumpFiles.length === 0) {
+            const matchedDirs = (await glob(resultsDir, {
+                mark: true,
+                nodir: false,
+                absolute: true,
+                dot: true,
+                windowsPathsNoEscape: true,
+                cwd,
+            })).filter((p) => p.endsWith(sep));
+            resultsDirectories.push(...matchedDirs);
+        }
+        if (resultsDirectories.length === 0 && stageDumpFiles.length === 0) {
+            console.log(red(`No test results directories found matching pattern: ${resultsDir}`));
+            return;
+        }
+        try {
+            const allureReport = new AllureReport(config);
+            await allureReport.restoreState(Array.from(stageDumpFiles));
+            await allureReport.start();
+            for (const dir of resultsDirectories) {
+                await allureReport.readDirectory(dir);
+            }
+            await allureReport.done();
+        }
+        catch (error) {
+            if (error instanceof KnownError) {
+                console.error(red(error.message));
+                exit(1);
+                return;
+            }
+            await logError("Failed to generate report due to unexpected error", error);
+            exit(1);
+        }
+    }
+}
+GenerateCommand.paths = [["generate"]];
+GenerateCommand.usage = Command.Usage({
     description: "Generates the report to specified directory",
-    options: [
+    details: "This command generates a report from the provided Allure Results directory.",
+    examples: [
+        ["generate ./allure-results", "Generate a report from the ./allure-results directory"],
         [
-            "--config, -c <file>",
-            {
-                description: "The path Allure config file",
-            },
+            "generate ./allure-results --output custom-report",
+            "Generate a report from the ./allure-results directory to the custom-report directory",
         ],
         [
-            "--output, -o <file>",
-            {
-                description: "The output directory name. Absolute paths are accepted as well (default: allure-report)",
-            },
+            "generate --stage=windows.zip --stage=macos.zip ./allure-results",
+            "Generate a report using data from windows.zip and macos.zip archives and using results from the ./allure-results directory",
         ],
         [
-            "--cwd <cwd>",
-            {
-                description: "The working directory for the command to run (default: current working directory)",
-            },
+            "generate --stage=allure-*.zip",
+            "Generate a report using data from any stage archive that matches the given pattern only (ignoring results directories)",
         ],
     ],
-    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 "@allure/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 { AllureReport, resolveConfig } from "@allurereport/core";
+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/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./history.js";
 export * from "./testplan.js";
 export * from "./classic.js";
+export * from "./allure2.js";
 export * from "./awesome.js";
 export * from "./csv.js";
 export * from "./history.js";
@@ -13,3 +14,9 @@ export * from "./open.js";
 export * from "./qualityGate.js";
 export * from "./log.js";
 export * from "./generate.js";
+export * from "./dashboard.js";
+export * from "./login.js";
+export * from "./logout.js";
+export * from "./whoami.js";
+export * from "./projects/index.js";
+export * from "./results/index.js";

package/dist/commands/index.js

@@ -1,6 +1,7 @@
 export * from "./history.js";
 export * from "./testplan.js";
 export * from "./classic.js";
+export * from "./allure2.js";
 export * from "./awesome.js";
 export * from "./csv.js";
 export * from "./history.js";
@@ -13,3 +14,9 @@ export * from "./open.js";
 export * from "./qualityGate.js";
 export * from "./log.js";
 export * from "./generate.js";
+export * from "./dashboard.js";
+export * from "./login.js";
+export * from "./logout.js";
+export * from "./whoami.js";
+export * from "./projects/index.js";
+export * from "./results/index.js";

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,27 +1,38 @@
-import { AllureReport, createConfig, writeKnownIssues } from "@allure/core";
+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 createConfig({});
-    const allureReport = new AllureReport(config);
-    const targetPath = resolve(output);
-    await allureReport.readDirectory(resultsDir);
-    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,7 +1,12 @@
-export type LogCommandOptions = {
-    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>;
+}