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

package/README.md

@@ -1,33 +1,165 @@
-# Allure CLI
- 
+# Allure 3
+
+**Allure 3** is the next evolution of the Allure reporting framework, rebuilt from the ground up with a new architecture and expanded capabilities. Unlike its predecessor, **Allure 2**, this version is developed in **TypeScript** and introduces a modular plugin system for greater flexibility. A key addition is the **Awesome** plugin, which delivers an enhanced UI for better report visualization.
+
+> 🚧 **Allure 3 is currently in beta and under active development.**  
+> Although not production-ready, we encourage users to install, explore, and share feedback with the development team.
+
+The **Allure 3 CLI** provides a comprehensive suite of commands designed to streamline the generation, serving, and management of test reports.
+
 [<img src="https://allurereport.org/public/img/allure-report.svg" height="85px" alt="Allure Report logo" align="right" />](https://allurereport.org "Allure Report")
 
 - Learn more about Allure Report at https://allurereport.org
 - 📚 [Documentation](https://allurereport.org/docs/) – discover official documentation for Allure Report
 - ❓ [Questions and Support](https://github.com/orgs/allure-framework/discussions/categories/questions-support) – get help from the team and community
-- 📢 [Official announcements](https://github.com/orgs/allure-framework/discussions/categories/announcements) – be in touch with the latest updates
+- 📢 [Official annoucements](https://github.com/orgs/allure-framework/discussions/categories/announcements) – be in touch with the latest updates
 - 💬 [General Discussion ](https://github.com/orgs/allure-framework/discussions/categories/general-discussion) – engage in casual conversations, share insights and ideas with the community
 
----
+## Key Features
+
+Allure 3 introduces several notable improvements. The framework has been entirely rewritten in **TypeScript**, making it more extensible and easier to maintain. Its **plugin system** allows you to customize and extend reporting functionality to fit your specific needs. Configuration has been simplified with a **single file** managing all report settings, making it more convenient to handle multiple reports.
+
+One of the standout features is **real-time reporting**, which lets you view live updates during test execution using the `watch` command. The report interface itself has been redesigned to enhance usability and clarity. Moreover, Allure 3 maintains **compatibility with the entire Allure ecosystem**, supporting all major test frameworks.
+
+> 🚧 Please note that **official CI/CD integrations and IDE plugins are not yet available** for Allure 3.
+
+## Installation
+
+To install Allure 3 globally, you can use [`npm`](https://docs.npmjs.com/downloading-and-installing-packages-globally). Simply run:
+
+```bash
+npm install -g allure
+```
+
+However, we recommend using `npx` for running Allure commands without needing a global installation:
+
+```bash
+npx allure run -- <test_command>
+```
+
+This approach ensures you always use the latest version without managing global dependencies.
 
-## Overview
+## Commands
 
-The Allure CLI is a main entry point which includes many sub-commands
+### Running Tests and Generating Reports
 
-## Install
+Running tests and generating a report with Allure 3 is straightforward. Using the `run` command, you can execute your test suite and automatically generate a report:
 
-Use your favorite package manager to install the package:
+```bash
+npx allure run -- <test_command>
+```
+
+For example, if you're using `npm` as your test runner, the command would be:
 
-```shell
-npm add allure
-yarn add allure
-pnpm add allure
+```bash
+npx allure run -- npm test
 ```
 
-## Usage
+To successfully generate a report, ensure that your test setup outputs results into an `allure-results` directory, which is automatically detected by Allure 3. This directory can be placed at any nested level within your project (e.g., `out/tests/allure-results`), provided it retains the correct name.
+
+After the tests complete, the report is generated automatically. Existing results from previous runs are ignored, as Allure 3 focuses solely on new data to ensure accurate and up-to-date reporting.
+
+### Generating Reports Manually
 
-The CLI provides a set of commands to work with Allure Report features. To see the list of available commands, run:
+If you already have test results and wish to generate a report manually, use the `generate` command:
 
-```shell
-allure --help
+```bash
+npx allure generate <resultsDir>
 ```
+
+By default, this command produces an **Allure 3 Awesome** report. You can customize output settings, such as the destination directory, through the configuration file. If you prefer a **Classic** or **Allure 2-style** report, or need to disable certain plugins, these adjustments can also be made via configuration.
+
+### Viewing Reports
+
+To view a previously generated report locally, the `open` command serves it in your default browser:
+
+```bash
+npx allure open <reportDir>
+```
+
+If you’ve defined the output directory in your configuration file, specifying `<reportDir>` is optional. By default, Allure 3 looks for a directory named `allure-report`. To open the Awesome report directly, point to the nested directory:
+
+```bash
+npx allure open allure-report/awesome
+```
+
+### Real-time Report Monitoring
+
+When you need to monitor test execution live, the `watch` command provides dynamic report updates. It continuously monitors the specified results directory for changes and refreshes the report automatically:
+
+```bash
+npx allure watch <allureResultsDir>
+```
+
+This command is ideal for iterative development and debugging, allowing you to see immediate feedback as you modify and rerun tests. The browser tab updates seamlessly whenever new results are detected.
+
+### Command-line Options
+
+The Allure CLI includes several helpful global options. Use `--help` to explore available commands or get detailed usage information for a specific command:
+
+```bash
+npx allure run --help
+npx allure watch --help
+```
+
+To check your installed version of Allure 3, use:
+
+```bash
+npx allure --version
+```
+
+
+## Configuration
+
+Allure 3 uses an `allurerc.mjs` configuration file to manage report settings, including the report name, output directory, and plugin options.
+
+> 💡 **Tip:** We recommend using the **Awesome** plugin for the best experience.  
+> Support for Classic and Allure 2-style reports is currently experimental.
+
+### Example Configuration File
+
+```js
+import { defineConfig } from "allure";
+
+export default defineConfig({
+  name: "Allure Report Example",
+  output: "./out/allure-report",
+  plugins: {
+    awesome: {
+      options: {
+        singleFile: true,
+        reportLanguage: "en",
+      },
+    },
+  },
+});
+```
+
+In this example, the generated report is named *Allure Report Example* and saved to the `./out/allure-report` directory. The **Awesome** plugin is enabled with options to produce a single-file HTML report in English.
+
+### Configuration Options
+
+The configuration file allows you to fine-tune report generation. Key options include:
+
+- **`name`**: Specifies the report’s display name.
+- **`output`**: Defines the directory where the report will be saved.
+- **`plugins`**: Enables and configures plugins, with each supporting various options.
+
+### Awesome Plugin Options
+
+The **Awesome** plugin offers several customizable options:
+
+- **`singleFile`** *(boolean)*: If set to `true`, generates the report as a single standalone HTML file.
+- **`reportName`** *(string)*: Overrides the default report name.
+- **`open`** *(boolean)*: Automatically opens the report after generation if enabled.
+- **`reportLanguage`** *(string)*: Sets the UI language of the report. Supported languages include:
+
+  `az`, `br`, `de`, `en`, `es`, `fr`, `he`, `ja`, `kr`, `nl`, `pl`, `ru`, `sv`, `tr`, `zh`.
+
+For example, setting `"reportLanguage": "fr"` will render the report interface in French.
+
+## Final Notes
+
+Allure 3 represents a significant step forward in test reporting, offering improved performance, flexibility, and an enhanced user interface. While it remains in beta, the framework is stable enough for exploration and feedback. We encourage you to experiment with the **Awesome** plugin and share your insights to help us refine the experience.
+
+Stay updated with the latest features, and don’t hesitate to contribute or report issues. Together, we can make Allure 3 the best it can be!

package/dist/commands/allure2.d.ts

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

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

package/dist/commands/awesome.d.ts

@@ -1,12 +1,18 @@
-type AwesomeCommandOptions = {
-    output?: string;
-    reportName?: string;
-    reportLanguage?: string;
-    logo?: string;
-    singleFile?: boolean;
-    historyPath?: string;
-    knownIssues?: 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,81 +1,89 @@
-import { AllureReport, resolveConfig } from "@allure/core";
-import { createCommand } from "../utils/commands.js";
-export const AwesomeCommandAction = async (resultsDir, options) => {
-    const before = new Date().getTime();
-    const { output, reportName: name, historyPath, knownIssues: knownIssuesPath, ...rest } = options;
-    const config = await resolveConfig({
-        output,
-        name,
-        historyPath,
-        knownIssuesPath,
-        plugins: {
-            "@allure/plugin-awesome": {
-                options: rest,
-            },
-        },
-    });
-    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: [
-        [
-            "--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>",
+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";
+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: "Path to the report logo which will be displayed in the header",
+                id: "awesome",
+                enabled: true,
+                options: defaultAwesomeOptions,
+                plugin: new AwesomePlugin(defaultAwesomeOptions),
             },
-        ],
-        [
-            "--theme <string>",
-            {
-                description: "Default theme of the report (default: OS theme)",
-            },
-        ],
-        [
-            "--report-language, --lang <string>",
-            {
-                description: "Default language of the report (default: OS language)",
-            },
-        ],
-        [
-            "--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)`);
+    }
+}
+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"],
         [
-            "--known-issues <file>",
-            {
-                description: "Path to the known issues file. Updates the file and quarantines failed tests when specified",
-            },
+            "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,11 +1,15 @@
-type ClassicCommandOptions = {
-    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,69 +1,77 @@
-import { AllureReport, resolveConfig } from "@allure/core";
-import { createCommand } from "../utils/commands.js";
-export const ClassicCommandAction = async (resultsDir, options) => {
-    const before = new Date().getTime();
-    const { output, reportName: name, historyPath, knownIssues: knownIssuesPath, ...rest } = options;
-    const config = await resolveConfig({
-        output,
-        name,
-        historyPath,
-        knownIssuesPath,
-        plugins: {
-            "@allure/plugin-classic": {
-                options: rest,
-            },
-        },
-    });
-    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: [
-        [
-            "--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>",
+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";
+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: "Default language of the report (default: OS language)",
+                id: "classic",
+                enabled: true,
+                options: defaultClassicOptions,
+                plugin: new ClassicPlugin(defaultClassicOptions),
             },
-        ],
-        [
-            "--single-file",
-            {
-                description: "Generate single file report",
-                default: false,
-            },
-        ],
-        [
-            "--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,
 });