allure 3.0.0-beta.2 → 3.0.0-beta.21

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,107 @@
-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 { 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) => /(\/|\\)$/.test(p));
+            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,10 @@ 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";
+export * from "./jira/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,10 @@ 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";
+export * from "./jira/index.js";

package/dist/commands/jira/clear.d.ts

@@ -0,0 +1,16 @@
+import { Command } from "clipanion";
+declare abstract class BaseJiraCommand extends Command {
+    config: string | undefined;
+    cwd: string | undefined;
+    token: string | undefined;
+    webhook: string | undefined;
+}
+export declare class JiraClearCommand extends BaseJiraCommand {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    issues: string[];
+    clearReports: boolean | undefined;
+    clearResults: boolean | undefined;
+    execute(): Promise<void>;
+}
+export {};

package/dist/commands/jira/clear.js

@@ -0,0 +1,113 @@
+import { getPluginInstance, readConfig } from "@allurereport/core";
+import JiraPlugin from "@allurereport/plugin-jira";
+import { Command, Option, UsageError } from "clipanion";
+import { realpath } from "node:fs/promises";
+import process, { exit } from "node:process";
+import { green, red } from "yoctocolors";
+class BaseJiraCommand 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.token = Option.String("--token,-t", {
+            description: "Atlassian User OAuth Token (default: ALLURE_JIRA_TOKEN environment variable)",
+            required: false,
+        });
+        this.webhook = Option.String("--webhook", {
+            description: "Allure Jira Integration Webhook URL (default: ALLURE_JIRA_WEBHOOK environment variable)",
+            required: false,
+        });
+    }
+}
+export class JiraClearCommand extends BaseJiraCommand {
+    constructor() {
+        super(...arguments);
+        this.issues = Option.Array("--issue", {
+            description: "Jira issue key(s)",
+            required: true,
+            arity: 1,
+        });
+        this.clearReports = Option.Boolean("--reports", {
+            description: "Unlink reports from the specified Jira issue",
+            required: false,
+        });
+        this.clearResults = Option.Boolean("--results", {
+            description: "Unlink results from the specified Jira issue",
+            required: false,
+        });
+    }
+    async execute() {
+        const cwd = await realpath(this.cwd ?? process.cwd());
+        const config = await readConfig(cwd, this.config);
+        const pluginFromConfig = getPluginInstance(config, ({ plugin }) => plugin instanceof JiraPlugin);
+        const jiraPlugin = new JiraPlugin({
+            token: this.token ?? pluginFromConfig?.options?.token,
+            webhook: this.webhook ?? pluginFromConfig?.options?.webhook,
+        });
+        if (!jiraPlugin.options.token) {
+            throw new UsageError("Token is not provided");
+        }
+        if (!jiraPlugin.options.webhook) {
+            throw new UsageError("Webhook url is not provided");
+        }
+        if (!this.clearReports && !this.clearResults) {
+            throw new UsageError("Either --reports or --results must be provided");
+        }
+        const operation = this.clearReports && this.clearResults ? "clearAll" : this.clearReports ? "clearReports" : "clearResults";
+        if (operation === "clearAll") {
+            try {
+                await jiraPlugin.clearAll(this.issues);
+                this.context.stdout.write(green("All reports and test results have been unlinked from the specified Jira issue"));
+            }
+            catch (error) {
+                this.context.stderr.write(red("Failed to unlink reports and test results from the specified Jira issue"));
+                exit(1);
+            }
+        }
+        if (operation === "clearReports") {
+            try {
+                await jiraPlugin.clearReports(this.issues);
+                this.context.stdout.write(green("All reports have been unlinked from the specified Jira issue"));
+            }
+            catch (error) {
+                this.context.stderr.write(red("Failed to unlink reports from the specified Jira issue"));
+                exit(1);
+            }
+        }
+        if (operation === "clearResults") {
+            try {
+                await jiraPlugin.clearResults(this.issues);
+                this.context.stdout.write(green("All test results have been unlinked from the specified Jira issue"));
+            }
+            catch (error) {
+                this.context.stderr.write(red("Failed to unlink test results from the specified Jira issue"));
+                exit(1);
+            }
+        }
+    }
+}
+JiraClearCommand.paths = [["jira", "clear"]];
+JiraClearCommand.usage = Command.Usage({
+    category: "Integrations",
+    description: "Unlink test results or reports in Jira",
+    details: "This command posts test results from the provided Allure Results directory to a Jira.",
+    examples: [
+        [
+            "Clear linked test results for the specified Jira issue",
+            "jira clear --token xoxb-token --webhook C12345 --issue JIRA-123 --results",
+        ],
+        [
+            "Clear linked reports for the specified Jira issue",
+            "jira clear --token xoxb-token --webhook C12345 --issue JIRA-123 --reports",
+        ],
+        [
+            "Clear linked test results and reports for the specified Jira issue",
+            "jira clear --token xoxb-token --webhook C12345 --issue JIRA-123 --results --reports",
+        ],
+        ["Clear from multiple Jira issues", "jira clear --issue JIRA-123 --issue JIRA-456 ..."],
+    ],
+});

package/dist/commands/jira/index.d.ts

@@ -0,0 +1 @@
+export * from "./clear.js";

package/dist/commands/jira/index.js

@@ -0,0 +1 @@
+export * from "./clear.js";