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

package/dist/commands/log.js

@@ -1,68 +1,64 @@
-import { AllureReport, enforcePlugin, readConfig } from "@allurereport/core";
+import { AllureReport, readConfig } from "@allurereport/core";
 import LogPlugin from "@allurereport/plugin-log";
+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 LogCommandAction = async (resultsDir, options) => {
-    const cwd = await realpath(options.cwd ?? process.cwd());
-    const before = new Date().getTime();
-    const { config: configPath, allSteps, withTrace, groupBy } = options;
-    const defaultLogOptions = {
-        allSteps,
-        withTrace,
-        groupBy,
-    };
-    const config = enforcePlugin(await readConfig(cwd, configPath), {
-        id: "log",
-        enabled: true,
-        options: defaultLogOptions,
-        plugin: new LogPlugin(defaultLogOptions),
-    });
-    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 LogCommand = createCommand({
-    name: "log <resultsDir>",
-    description: "Prints Allure Results to the console",
-    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)",
-            },
-        ],
-        [
-            "--group-by <label>",
-            {
-                description: "Group tests by type (none, suite, feature, package, etc.)",
-                default: "suite",
-            },
-        ],
-        [
-            "--all-steps",
+export class LogCommand 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.groupBy = Option.String("--group-by", {
+            description: "Group tests by type (none, suite, feature, package, etc.)",
+        });
+        this.allSteps = Option.Boolean("--all-steps", {
+            description: "Show all steps. By default only failed steps are shown",
+        });
+        this.withTrace = Option.Boolean("--with-trace", {
+            description: "Print stack trace for failed tests",
+        });
+    }
+    async execute() {
+        const cwd = await realpath(this.cwd ?? process.cwd());
+        const before = new Date().getTime();
+        const defaultLogOptions = {
+            allSteps: this.allSteps ?? false,
+            withTrace: this.withTrace ?? false,
+            groupBy: this.groupBy ?? "suite",
+        };
+        const config = await readConfig(cwd, this.config);
+        config.plugins = [
             {
-                description: "Show all steps. By default only failed steps are shown",
-                default: false,
+                id: "log",
+                enabled: true,
+                options: defaultLogOptions,
+                plugin: new LogPlugin(defaultLogOptions),
             },
-        ],
+        ];
+        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)`);
+    }
+}
+LogCommand.paths = [["log"]];
+LogCommand.usage = Command.Usage({
+    category: "Reports",
+    description: "Prints Allure Results to the console",
+    details: "This command prints Allure Results to the console from the provided Allure Results directory.",
+    examples: [
+        ["log ./allure-results", "Print results from the ./allure-results directory"],
         [
-            "--with-trace",
-            {
-                description: "Print stack trace for failed tests",
-                default: false,
-            },
+            "log ./allure-results --all-steps --with-trace",
+            "Print results with all steps and stack traces from the ./allure-results directory",
         ],
     ],
-    action: LogCommandAction,
 });

package/dist/commands/login.d.ts

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

package/dist/commands/login.js

@@ -1,47 +1,50 @@
 import { readConfig } from "@allurereport/core";
 import { AllureServiceClient, KnownError } from "@allurereport/service";
+import { Command, Option } from "clipanion";
+import * as console from "node:console";
+import { exit } from "node:process";
 import { green, red } from "yoctocolors";
-import { createCommand } from "../utils/commands.js";
 import { logError } from "../utils/logs.js";
-export const LoginCommandAction = async (options) => {
-    const { config: configPath, cwd } = options ?? {};
-    const config = await readConfig(cwd, configPath);
-    if (!config?.allureService?.url) {
-        console.error(red("No Allure Service URL is provided. Please provide it in the `allureService.url` field in the `allure.config.js` file"));
-        process.exit(1);
-        return;
+export class LoginCommand 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)",
+        });
     }
-    const serviceClient = new AllureServiceClient(config.allureService);
-    try {
-        await serviceClient.login();
-        console.info(green("Logged in"));
-    }
-    catch (error) {
-        if (error instanceof KnownError) {
-            console.error(red(error.message));
-            process.exit(1);
+    async execute() {
+        const config = await readConfig(this.cwd, this.config);
+        if (!config?.allureService?.url) {
+            console.error(red("No Allure Service URL is provided. Please provide it in the `allureService.url` field in the `allure.config.js` file"));
+            exit(1);
             return;
         }
-        await logError("Failed to login due to unexpected error", error);
-        process.exit(1);
+        const serviceClient = new AllureServiceClient(config.allureService);
+        try {
+            await serviceClient.login();
+            console.info(green("Logged in"));
+        }
+        catch (error) {
+            if (error instanceof KnownError) {
+                console.error(red(error.message));
+                exit(1);
+                return;
+            }
+            await logError("Failed to login due to unexpected error", error);
+            exit(1);
+        }
     }
-};
-export const LoginCommand = createCommand({
-    name: "login",
+}
+LoginCommand.paths = [["login"]];
+LoginCommand.usage = Command.Usage({
+    category: "Allure Service",
     description: "Logs in to the Allure Service",
-    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)",
-            },
-        ],
+    details: "This command logs in to the Allure Service using the configuration from the Allure config file.",
+    examples: [
+        ["login", "Log in to the Allure Service using the default configuration"],
+        ["login --config custom-config.js", "Log in to the Allure Service using a custom configuration file"],
     ],
-    action: LoginCommandAction,
 });

package/dist/commands/logout.d.ts

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

package/dist/commands/logout.js

@@ -1,47 +1,50 @@
 import { readConfig } from "@allurereport/core";
 import { AllureServiceClient, KnownError } from "@allurereport/service";
+import { Command, Option } from "clipanion";
+import * as console from "node:console";
+import { exit } from "node:process";
 import { green, red } from "yoctocolors";
-import { createCommand } from "../utils/commands.js";
 import { logError } from "../utils/logs.js";
-export const LogoutCommandAction = async (options) => {
-    const { config: configPath, cwd } = options ?? {};
-    const config = await readConfig(cwd, configPath);
-    if (!config?.allureService?.url) {
-        console.error(red("No Allure Service URL is provided. Please provide it in the `allureService.url` field in the `allure.config.js` file"));
-        process.exit(1);
-        return;
+export class LogoutCommand 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)",
+        });
     }
-    const serviceClient = new AllureServiceClient(config.allureService);
-    try {
-        await serviceClient.logout();
-        console.info(green("Logged out"));
-    }
-    catch (error) {
-        if (error instanceof KnownError) {
-            console.error(red(error.message));
-            process.exit(1);
+    async execute() {
+        const config = await readConfig(this.cwd, this.config);
+        if (!config?.allureService?.url) {
+            console.error(red("No Allure Service URL is provided. Please provide it in the `allureService.url` field in the `allure.config.js` file"));
+            exit(1);
             return;
         }
-        await logError("Failed to logout due to unexpected error", error);
-        process.exit(1);
+        const serviceClient = new AllureServiceClient(config.allureService);
+        try {
+            await serviceClient.logout();
+            console.info(green("Logged out"));
+        }
+        catch (error) {
+            if (error instanceof KnownError) {
+                console.error(red(error.message));
+                exit(1);
+                return;
+            }
+            await logError("Failed to logout due to unexpected error", error);
+            exit(1);
+        }
     }
-};
-export const LogoutCommand = createCommand({
-    name: "logout",
+}
+LogoutCommand.paths = [["logout"]];
+LogoutCommand.usage = Command.Usage({
+    category: "Allure Service",
     description: "Logs out from the Allure Service",
-    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)",
-            },
-        ],
+    details: "This command logs out from the Allure Service using the configuration from the Allure config file.",
+    examples: [
+        ["logout", "Log out from the Allure Service using the default configuration"],
+        ["logout --config custom-config.js", "Log out from the Allure Service using a custom configuration file"],
     ],
-    action: LogoutCommandAction,
 });

package/dist/commands/open.d.ts

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

package/dist/commands/open.js

@@ -1,45 +1,39 @@
 import { readConfig } from "@allurereport/core";
 import { serve } from "@allurereport/static-server";
-import { createCommand } from "../utils/commands.js";
-export const OpenCommandAction = async (reportDir, options) => {
-    const { config: configPath, port, live, cwd } = options;
-    const config = await readConfig(cwd, configPath, { output: reportDir });
-    await serve({
-        port: port,
-        servePath: config.output,
-        live: Boolean(live),
-        open: true,
-    });
-};
-export const OpenCommand = createCommand({
-    name: "open [reportDir]",
+import { Command, Option } from "clipanion";
+export class OpenCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.reportDir = Option.String({ required: false, name: "The directory with Allure results" });
+        this.config = Option.String("--config,-c", {
+            description: "The path Allure config file",
+        });
+        this.port = Option.String("--port", {
+            description: "The port to serve the reports on. If not set, the server starts on a random port",
+        });
+        this.live = Option.Boolean("--live", {
+            description: "Reload pages on any file change in the served directory",
+        });
+        this.cwd = Option.String("--cwd", {
+            description: "The working directory for the command to run (default: current working directory)",
+        });
+    }
+    async execute() {
+        const config = await readConfig(this.cwd, this.config, { output: this.reportDir ?? "./allure-report" });
+        await serve({
+            port: this.port ? parseInt(this.port, 10) : undefined,
+            servePath: config.output,
+            live: this.live ?? false,
+            open: true,
+        });
+    }
+}
+OpenCommand.paths = [["open"]];
+OpenCommand.usage = Command.Usage({
     description: "Serves specified directory",
-    options: [
-        [
-            "--config, -c <file>",
-            {
-                description: "The path Allure config file",
-            },
-        ],
-        [
-            "--port <string>",
-            {
-                description: "The port to serve the reports on. If not set, the server starts on a random port",
-            },
-        ],
-        [
-            "--live",
-            {
-                description: "Reload pages on any file change in the served directory",
-                default: false,
-            },
-        ],
-        [
-            "--cwd <cwd>",
-            {
-                description: "The working directory for the command to run (default: current working directory)",
-            },
-        ],
+    details: "This command serves the specified report directory and opens it in the default browser.",
+    examples: [
+        ["open", "Serve the default report directory"],
+        ["open custom-report --port 8080 --live", "Serve the custom-report directory on port 8080 with live reload"],
     ],
-    action: OpenCommandAction,
 });

package/dist/commands/projects/create.d.ts

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

package/dist/commands/projects/create.js

@@ -1,79 +1,83 @@
 import { getGitRepoName, readConfig } from "@allurereport/core";
 import { AllureServiceClient, KnownError } from "@allurereport/service";
+import { Command, Option } from "clipanion";
+import * as console from "node:console";
+import { exit } from "node:process";
 import prompts from "prompts";
 import { green, red } from "yoctocolors";
-import { createCommand } from "../../utils/commands.js";
 import { logError } from "../../utils/logs.js";
-export const ProjectsCreateCommandAction = async (projectName, options) => {
-    const { config: configPath, cwd } = options ?? {};
-    const config = await readConfig(cwd, configPath);
-    if (!config?.allureService?.url) {
-        console.error(red("No Allure Service URL is provided. Please provide it in the `allureService.url` field in the `allure.config.js` file"));
-        process.exit(1);
-        return;
-    }
-    const serviceClient = new AllureServiceClient(config.allureService);
-    let name = projectName;
-    if (!name) {
-        try {
-            name = await getGitRepoName();
-        }
-        catch (ignored) { }
-    }
-    if (!name) {
-        const res = await prompts({
-            type: "text",
-            name: "name",
-            message: "Enter project name",
+export class ProjectsCreateCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.projectName = Option.String({ required: false, name: "Project name" });
+        this.config = Option.String("--config,-c", {
+            description: "The path Allure config file",
         });
-        name = res?.name;
-    }
-    if (!name) {
-        console.error(red("No project name provided!"));
-        process.exit(1);
-        return;
-    }
-    try {
-        const project = await serviceClient.createProject({
-            name,
+        this.cwd = Option.String("--cwd", {
+            description: "The working directory for the command to run (default: current working directory)",
         });
-        const lines = [
-            `The "${green(project.name)}" has been created. Insert following code into your Allure Config file, to enable Allure Service features for the project:`,
-            "",
-            green("{"),
-            green("  allureService: {"),
-            green(`    project: "${project.name}"`),
-            green("  }"),
-            green("}"),
-        ];
-        console.info(lines.join("\n"));
     }
-    catch (error) {
-        if (error instanceof KnownError) {
-            console.error(red(error.message));
-            process.exit(1);
+    async execute() {
+        const config = await readConfig(this.cwd, this.config);
+        if (!config?.allureService?.url) {
+            console.error(red("No Allure Service URL is provided. Please provide it in the `allureService.url` field in the `allure.config.js` file"));
+            exit(1);
             return;
         }
-        await logError("Failed to create project due to unexpected error", error);
-        process.exit(1);
+        const serviceClient = new AllureServiceClient(config.allureService);
+        let name = this.projectName;
+        if (!name) {
+            try {
+                name = await getGitRepoName();
+            }
+            catch (ignored) { }
+        }
+        if (!name) {
+            const res = await prompts({
+                type: "text",
+                name: "name",
+                message: "Enter project name",
+            });
+            name = res?.name;
+        }
+        if (!name) {
+            console.error(red("No project name provided!"));
+            exit(1);
+            return;
+        }
+        try {
+            const project = await serviceClient.createProject({
+                name,
+            });
+            const lines = [
+                `The "${green(project.name)}" has been created. Insert following code into your Allure Config file, to enable Allure Service features for the project:`,
+                "",
+                green("{"),
+                green("  allureService: {"),
+                green(`    project: "${project.name}"`),
+                green("  }"),
+                green("}"),
+            ];
+            console.info(lines.join("\n"));
+        }
+        catch (error) {
+            if (error instanceof KnownError) {
+                console.error(red(error.message));
+                exit(1);
+                return;
+            }
+            await logError("Failed to create project due to unexpected error", error);
+            exit(1);
+        }
     }
-};
-export const ProjectsCreateCommand = createCommand({
-    name: "project-create [name]",
-    description: "",
-    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)",
-            },
-        ],
+}
+ProjectsCreateCommand.paths = [["projects", "create"]];
+ProjectsCreateCommand.usage = Command.Usage({
+    category: "Allure Service Projects",
+    description: "Creates a new project",
+    details: "This command creates a new project in the Allure Service.",
+    examples: [
+        ["project-create my-project", "Create a new project named 'my-project'"],
+        ["project-create", "Create a new project with a name from git repo or prompt for a name"],
     ],
-    action: ProjectsCreateCommandAction,
 });

package/dist/commands/projects/delete.d.ts

@@ -1,7 +1,10 @@
-export type CommandOptions = {
-    force?: boolean;
-    config?: string;
-    cwd?: string;
-};
-export declare const ProjectsDeleteCommandAction: (projectName?: string, options?: CommandOptions) => Promise<void>;
-export declare const ProjectsDeleteCommand: (cli: import("cac").CAC) => void;
+import { Command } from "clipanion";
+export declare class ProjectsDeleteCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    projectName: string;
+    force: boolean | undefined;
+    config: string | undefined;
+    cwd: string | undefined;
+    execute(): Promise<void>;
+}