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

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>;
+}

package/dist/commands/log.js

@@ -1,46 +1,64 @@
-import { AllureReport, resolveConfig } from "@allure/core";
-import { createCommand } from "../utils/commands.js";
-export const LogCommandAction = async (resultsDir, options) => {
-    const before = new Date().getTime();
-    const config = await resolveConfig({
-        plugins: {
-            "@allure/plugin-log": {
-                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 LogCommand = createCommand({
-    name: "log <resultsDir>",
-    description: "Prints Allure Results to the console",
-    options: [
-        [
-            "--group-by <label>",
+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";
+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: "Group tests by type (none, suite, feature, package, etc.)",
-                default: "suite",
+                id: "log",
+                enabled: true,
+                options: defaultLogOptions,
+                plugin: new LogPlugin(defaultLogOptions),
             },
-        ],
-        [
-            "--all-steps",
-            {
-                description: "Show all steps. By default only failed steps are shown",
-                default: false,
-            },
-        ],
+        ];
+        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

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

@@ -0,0 +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 { logError } from "../utils/logs.js";
+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)",
+        });
+    }
+    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;
+        }
+        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);
+        }
+    }
+}
+LoginCommand.paths = [["login"]];
+LoginCommand.usage = Command.Usage({
+    category: "Allure Service",
+    description: "Logs in to the Allure Service",
+    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"],
+    ],
+});

package/dist/commands/logout.d.ts

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

@@ -0,0 +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 { logError } from "../utils/logs.js";
+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)",
+        });
+    }
+    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;
+        }
+        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);
+        }
+    }
+}
+LogoutCommand.paths = [["logout"]];
+LogoutCommand.usage = Command.Usage({
+    category: "Allure Service",
+    description: "Logs out from the Allure Service",
+    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"],
+    ],
+});

package/dist/commands/open.d.ts

@@ -1,8 +1,11 @@
-type CommandOptions = {
-    config?: 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,39 +1,39 @@
-import { readRuntimeConfig } from "@allure/core";
-import { serve } from "@allure/static-server";
-import { createCommand } from "../utils/commands.js";
-export const OpenCommandAction = async (reportDir, options) => {
-    const { config: configPath, port, live } = options;
-    const config = await readRuntimeConfig(configPath, undefined, reportDir);
-    await serve({
-        port: port,
-        servePath: config.output,
-        live: Boolean(live),
-        open: true,
-    });
-};
-export const OpenCommand = createCommand({
-    name: "open [reportDir]",
+import { readConfig } from "@allurereport/core";
+import { serve } from "@allurereport/static-server";
+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,
-            },
-        ],
+    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

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

@@ -0,0 +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 { logError } from "../../utils/logs.js";
+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",
+        });
+        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);
+        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;
+        }
+        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);
+        }
+    }
+}
+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"],
+    ],
+});

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

@@ -0,0 +1,10 @@
+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>;
+}

package/dist/commands/projects/delete.js

@@ -0,0 +1,68 @@
+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 prompts from "prompts";
+import { green, red } from "yoctocolors";
+import { logError } from "../../utils/logs.js";
+export class ProjectsDeleteCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.projectName = Option.String({ required: true, name: "Project name" });
+        this.force = Option.Boolean("--force", {
+            description: "Delete project with no confirmation",
+        });
+        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)",
+        });
+    }
+    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;
+        }
+        const serviceClient = new AllureServiceClient(config.allureService);
+        if (!this.force) {
+            const res = await prompts({
+                type: "confirm",
+                name: "value",
+                message: `Are you sure you want to delete project "${this.projectName}"?`,
+            });
+            if (!res.value) {
+                exit(0);
+                return;
+            }
+        }
+        try {
+            await serviceClient.deleteProject({
+                name: this.projectName,
+            });
+            console.info(green("Project has been deleted"));
+        }
+        catch (error) {
+            if (error instanceof KnownError) {
+                console.error(red(error.message));
+                exit(1);
+                return;
+            }
+            await logError("Failed to delete project due to unexpected error", error);
+            exit(1);
+        }
+    }
+}
+ProjectsDeleteCommand.paths = [["projects", "delete"]];
+ProjectsDeleteCommand.usage = Command.Usage({
+    category: "Allure Service Projects",
+    description: "Deletes a project",
+    details: "This command deletes a project from the Allure Service.",
+    examples: [
+        ["project delete my-project", "Delete the project named 'my-project' (with confirmation)"],
+        ["project delete my-project --force", "Delete the project named 'my-project' without confirmation"],
+    ],
+});

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

@@ -0,0 +1,3 @@
+export * from "./create.js";
+export * from "./delete.js";
+export * from "./list.js";

package/dist/commands/projects/index.js

@@ -0,0 +1,3 @@
+export * from "./create.js";
+export * from "./delete.js";
+export * from "./list.js";

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

@@ -0,0 +1,8 @@
+import { Command } from "clipanion";
+export declare class ProjectsListCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    config: string | undefined;
+    cwd: string | undefined;
+    execute(): Promise<void>;
+}