allure 3.0.0-beta.16 → 3.0.0-beta.18

package/dist/commands/testplan.js

@@ -1,38 +1,45 @@
 import { AllureReport, resolveConfig } from "@allurereport/core";
+import { Command, Option } from "clipanion";
 import * as console from "node:console";
 import { basename, dirname, resolve } from "node:path";
-import { createCommand } from "../utils/commands.js";
-export const TestPlanCommandAction = async (resultsDir, options) => {
-    const before = new Date().getTime();
-    const resolved = resolve(options.output ?? "./testplan.json");
-    const output = dirname(resolved);
-    const fileName = basename(resolved);
-    const config = await resolveConfig({
-        output: output,
-        plugins: {
-            "@allurereport/plugin-testplan": {
-                options: { fileName },
+export class TestPlanCommand 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 before = new Date().getTime();
+        const resolved = resolve(this.output ?? "./testplan.json");
+        const output = dirname(resolved);
+        const fileName = basename(resolved);
+        const config = await resolveConfig({
+            output: output,
+            plugins: {
+                "@allurereport/plugin-testplan": {
+                    options: { fileName },
+                },
             },
-        },
-    });
-    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 TestPlanCommand = createCommand({
-    name: "testplan <resultsDir>",
+        });
+        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)`);
+    }
+}
+TestPlanCommand.paths = [["testplan"]];
+TestPlanCommand.usage = Command.Usage({
     description: "Generates testplan.json based on provided Allure Results",
-    options: [
+    details: "This command generates a testplan.json file from the provided Allure Results directory.",
+    examples: [
+        ["testplan ./allure-results", "Generate a testplan.json file from the ./allure-results directory"],
         [
-            "--output, -o <file>",
-            {
-                description: "The output file name. Absolute paths are accepted as well",
-                default: "testplan.json",
-            },
+            "testplan ./allure-results --output custom-testplan.json",
+            "Generate a custom-testplan.json file from the ./allure-results directory",
         ],
     ],
-    action: TestPlanCommandAction,
 });

package/dist/commands/watch.d.ts

@@ -1,10 +1,12 @@
-type WatchCommandOptions = {
-    config?: string;
-    output?: string;
-    cwd?: string;
-    reportName?: string;
-    port?: string;
-};
-export declare const WatchCommandAction: (resultsDir: string, options: WatchCommandOptions) => Promise<void>;
-export declare const WatchCommand: (cli: import("cac").CAC) => void;
-export {};
+import { Command } from "clipanion";
+export declare class WatchCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    resultsDir: string;
+    config: string | undefined;
+    cwd: string | undefined;
+    output: string | undefined;
+    reportName: string | undefined;
+    port: string | undefined;
+    execute(): Promise<void>;
+}

package/dist/commands/watch.js

@@ -5,114 +5,118 @@ import ProgressPlugin from "@allurereport/plugin-progress";
 import ServerReloadPlugin from "@allurereport/plugin-server-reload";
 import { PathResultFile } from "@allurereport/reader-api";
 import { serve } from "@allurereport/static-server";
+import { Command, Option } from "clipanion";
 import * as console from "node:console";
 import { rm } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import process from "node:process";
-import { createCommand } from "../utils/commands.js";
-export const WatchCommandAction = async (resultsDir, options) => {
-    const before = new Date().getTime();
-    process.on("exit", (code) => {
-        const after = new Date().getTime();
-        console.log(`exit code ${code} (${after - before}ms)`);
-    });
-    const { config: configPath, output, cwd, reportName } = options;
-    const config = await readConfig(cwd, configPath, { output, name: reportName });
-    try {
-        await rm(config.output, { recursive: true });
+export class WatchCommand 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, allure.csv by default. Accepts absolute paths (default: ./allure-report)",
+        });
+        this.reportName = Option.String("--report-name,--name", {
+            description: "The report name (default: Allure Report)",
+        });
+        this.port = Option.String("--port", {
+            description: "The port to serve the reports on (default: random port)",
+        });
     }
-    catch (e) {
-        if (!isFileNotFoundError(e)) {
-            console.error("could not clean output directory", e);
+    async execute() {
+        const before = new Date().getTime();
+        process.on("exit", (code) => {
+            const after = new Date().getTime();
+            console.log(`exit code ${code} (${after - before}ms)`);
+        });
+        const config = await readConfig(this.cwd, this.config, {
+            output: this.output,
+            name: this.reportName,
+        });
+        try {
+            await rm(config.output, { recursive: true });
         }
+        catch (e) {
+            if (!isFileNotFoundError(e)) {
+                console.error("could not clean output directory", e);
+            }
+        }
+        const server = await serve({
+            servePath: config.output,
+            port: this.port ? parseInt(this.port, 10) : undefined,
+            live: false,
+            open: false,
+        });
+        const allureReport = new AllureReport({
+            ...config,
+            realTime: true,
+            plugins: [
+                ...(config.plugins?.length
+                    ? config.plugins
+                    : [
+                        {
+                            id: "awesome",
+                            enabled: true,
+                            options: {},
+                            plugin: new Awesome({
+                                reportName: config.name,
+                            }),
+                        },
+                    ]),
+                {
+                    id: "watch log",
+                    enabled: true,
+                    options: {},
+                    plugin: new ProgressPlugin(),
+                },
+                {
+                    id: "server reload",
+                    enabled: true,
+                    options: {},
+                    plugin: new ServerReloadPlugin({
+                        server,
+                    }),
+                },
+            ],
+        });
+        await allureReport.start();
+        const input = resolve(this.resultsDir[0]);
+        const { abort } = newFilesInDirectoryWatcher(input, async (path) => {
+            await allureReport.readResult(new PathResultFile(path));
+        });
+        const pluginIdToOpen = config.plugins?.find((plugin) => !!plugin.options.open)?.id;
+        if (pluginIdToOpen) {
+            await server.open(join(server.url, pluginIdToOpen));
+        }
+        else {
+            await server.open(server.url);
+        }
+        console.info("Press Ctrl+C to exit");
+        process.on("SIGINT", async () => {
+            console.log("");
+            await abort();
+            await server.stop();
+            await allureReport.done();
+            process.exit(0);
+        });
     }
-    const server = await serve({
-        servePath: config.output,
-        port: options.port ? parseInt(options.port, 10) : undefined,
-        live: false,
-        open: false,
-    });
-    const allureReport = new AllureReport({
-        ...config,
-        realTime: true,
-        plugins: [
-            ...(config.plugins?.length
-                ? config.plugins
-                : [
-                    {
-                        id: "awesome",
-                        enabled: true,
-                        options: {},
-                        plugin: new Awesome({
-                            reportName: config.name,
-                        }),
-                    },
-                ]),
-            {
-                id: "watch log",
-                enabled: true,
-                options: {},
-                plugin: new ProgressPlugin(),
-            },
-            {
-                id: "server reload",
-                enabled: true,
-                options: {},
-                plugin: new ServerReloadPlugin({
-                    server,
-                }),
-            },
-        ],
-    });
-    await allureReport.start();
-    const input = resolve(resultsDir);
-    const { abort } = newFilesInDirectoryWatcher(input, async (path) => {
-        await allureReport.readResult(new PathResultFile(path));
-    });
-    const pluginIdToOpen = config.plugins?.find((plugin) => !!plugin.options.open)?.id;
-    if (pluginIdToOpen) {
-        await server.open(join(server.url, pluginIdToOpen));
-    }
-    else {
-        await server.open(server.url);
-    }
-    console.info("Press Ctrl+C to exit");
-    process.on("SIGINT", async () => {
-        console.log("");
-        await abort();
-        await server.stop();
-        await allureReport.done();
-        process.exit(0);
-    });
-};
-export const WatchCommand = createCommand({
-    name: "watch <resultsDir>",
+}
+WatchCommand.paths = [["watch"]];
+WatchCommand.usage = Command.Usage({
     description: "Watches Allure Results changes in Real-time",
-    options: [
-        [
-            "--cwd <cwd>",
-            {
-                description: "The working directory for the command to run (default: current working directory)",
-            },
-        ],
-        [
-            "--output, -o <file>",
-            {
-                description: "The output file name, allure.csv by default. Accepts absolute paths (default: ./allure-report)",
-            },
-        ],
-        [
-            "--report-name, --name <string>",
-            {
-                description: "The report name (default: Allure Report)",
-            },
-        ],
+    details: "This command watches for changes in the Allure Results directory and updates the report in real-time.",
+    examples: [
+        ["watch ./allure-results", "Watch for changes in the ./allure-results directory"],
         [
-            "--port <port>",
-            {
-                description: "The port to serve the reports on (default: random port)",
-            },
+            "watch ./allure-results --port 8080",
+            "Watch for changes in the ./allure-results directory and serve the report on port 8080",
         ],
     ],
-    action: WatchCommandAction,
 });

package/dist/commands/whoami.d.ts

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

package/dist/commands/whoami.js

@@ -1,51 +1,57 @@
 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 WhoamiCommandAction = 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 WhoamiCommand 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 {
-        const profile = await serviceClient.profile();
-        const lines = [`You are logged in as "${profile.email}"`];
-        if (config.allureService?.project) {
-            lines.push(`Current project is "${config.allureService.project}"`);
-        }
-        console.info(green(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 get profile due to unexpected error", error);
-        process.exit(1);
+        const serviceClient = new AllureServiceClient(config.allureService);
+        try {
+            const profile = await serviceClient.profile();
+            const lines = [`You are logged in as "${profile.email}"`];
+            if (config.allureService?.project) {
+                lines.push(`Current project is "${config.allureService.project}"`);
+            }
+            console.info(green(lines.join("\n")));
+        }
+        catch (error) {
+            if (error instanceof KnownError) {
+                console.error(red(error.message));
+                exit(1);
+                return;
+            }
+            await logError("Failed to get profile due to unexpected error", error);
+            exit(1);
+        }
     }
-};
-export const WhoamiCommand = createCommand({
-    name: "whoami",
+}
+WhoamiCommand.paths = [["whoami"]];
+WhoamiCommand.usage = Command.Usage({
+    category: "Allure Service",
     description: "Prints information about current user",
-    options: [
-        [
-            "--config, -c <file>",
-            {
-                description: "The path Allure config file",
-            },
-        ],
+    details: "This command prints information about the current user logged in to the Allure Service.",
+    examples: [
+        ["whoami", "Print information about the current user using the default configuration"],
         [
-            "--cwd <cwd>",
-            {
-                description: "The working directory for the command to run (default: current working directory)",
-            },
+            "whoami --config custom-config.js",
+            "Print information about the current user using a custom configuration file",
         ],
     ],
-    action: WhoamiCommandAction,
 });

package/dist/index.js

@@ -1,41 +1,39 @@
-import { cac } from "cac";
+import { Builtins, Cli } from "clipanion";
 import console from "node:console";
 import { readFileSync } from "node:fs";
-import { cwd } from "node:process";
-import { AwesomeCommand, ClassicCommand, ClassicLegacyCommand, CsvCommand, DashboardCommand, GenerateCommand, HistoryCommand, KnownIssueCommand, LogCommand, LoginCommand, LogoutCommand, OpenCommand, ProjectsCreateCommand, ProjectsDeleteCommand, ProjectsListCommand, QualityGateCommand, RunCommand, SlackCommand, TestPlanCommand, WatchCommand, WhoamiCommand, } from "./commands/index.js";
+import { argv, cwd } from "node:process";
+import { Allure2Command, AwesomeCommand, ClassicCommand, CsvCommand, DashboardCommand, GenerateCommand, HistoryCommand, KnownIssueCommand, LogCommand, LoginCommand, LogoutCommand, OpenCommand, ProjectsCreateCommand, ProjectsDeleteCommand, ProjectsListCommand, QualityGateCommand, ResultsPackCommand, ResultsUnpackCommand, RunCommand, SlackCommand, TestPlanCommand, WatchCommand, WhoamiCommand, } from "./commands/index.js";
+const [node, app, ...args] = argv;
 const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
-const cli = cac(pkg.name).usage(pkg.description).help().version(pkg.version);
-const commands = [
-    ClassicCommand,
-    ClassicLegacyCommand,
-    AwesomeCommand,
-    CsvCommand,
-    DashboardCommand,
-    GenerateCommand,
-    HistoryCommand,
-    KnownIssueCommand,
-    LogCommand,
-    OpenCommand,
-    QualityGateCommand,
-    RunCommand,
-    SlackCommand,
-    TestPlanCommand,
-    WatchCommand,
-    LoginCommand,
-    LogoutCommand,
-    WhoamiCommand,
-    ProjectsCreateCommand,
-    ProjectsDeleteCommand,
-    ProjectsListCommand,
-];
-commands.forEach((command) => {
-    command(cli);
-});
-cli.on("command:*", () => {
-    console.error(`Invalid command: "${cli.args.join(" ")}"`);
-    console.error("See --help for a list of available commands");
-    process.exit(1);
+const cli = new Cli({
+    binaryName: pkg.name,
+    binaryLabel: `${node} ${app}`,
+    binaryVersion: pkg.version,
 });
+cli.register(AwesomeCommand);
+cli.register(Allure2Command);
+cli.register(ClassicCommand);
+cli.register(CsvCommand);
+cli.register(DashboardCommand);
+cli.register(GenerateCommand);
+cli.register(HistoryCommand);
+cli.register(KnownIssueCommand);
+cli.register(LogCommand);
+cli.register(LoginCommand);
+cli.register(LogoutCommand);
+cli.register(OpenCommand);
+cli.register(QualityGateCommand);
+cli.register(RunCommand);
+cli.register(SlackCommand);
+cli.register(TestPlanCommand);
+cli.register(WatchCommand);
+cli.register(WhoamiCommand);
+cli.register(ProjectsCreateCommand);
+cli.register(ProjectsDeleteCommand);
+cli.register(ProjectsListCommand);
+cli.register(ResultsPackCommand);
+cli.register(ResultsUnpackCommand);
+cli.register(Builtins.HelpCommand);
+cli.runExit(args);
 console.log(cwd());
-cli.parse();
 export { defineConfig } from "@allurereport/plugin-api";

package/dist/utils/process.d.ts

@@ -1,3 +1,9 @@
 import type { ChildProcess } from "node:child_process";
-export declare const runProcess: (command: string, commandArgs: string[], cwd: string | undefined, environment: Record<string, string>, silent?: boolean) => ChildProcess;
+export declare const runProcess: (params: {
+    command: string;
+    commandArgs: string[];
+    cwd: string | undefined;
+    environment?: Record<string, string>;
+    logs?: "pipe" | "inherit" | "ignore";
+}) => ChildProcess;
 export declare const terminationOf: (testProcess: ChildProcess) => Promise<number | null>;

package/dist/utils/process.js

@@ -1,12 +1,23 @@
 import { spawn } from "node:child_process";
-export const runProcess = (command, commandArgs, cwd, environment, silent) => {
+export const runProcess = (params) => {
+    const { command, commandArgs, cwd, environment = {}, logs = "inherit" } = params;
+    const env = {
+        ...process.env,
+        ...environment,
+    };
+    if (logs === "pipe") {
+        Object.assign(env, {
+            FORCE_COLOR: "1",
+            CLICOLOR_FORCE: "1",
+            COLOR: "1",
+            COLORTERM: "truecolor",
+            TERM: "xterm-256color",
+        });
+    }
     return spawn(command, commandArgs, {
-        env: {
-            ...process.env,
-            ...environment,
-        },
+        env,
         cwd,
-        stdio: silent ? "ignore" : "inherit",
+        stdio: logs,
         shell: true,
     });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allure",
-  "version": "3.0.0-beta.16",
+  "version": "3.0.0-beta.18",
   "description": "Allure Commandline Tool",
   "keywords": [
     "allure",
@@ -12,7 +12,8 @@
   "author": "Qameta Software",
   "type": "module",
   "exports": {
-    ".": "./dist/index.js"
+    ".": "./dist/index.js",
+    "./qualityGate": "./dist/qualityGate.js"
   },
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -30,38 +31,44 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@allurereport/core": "3.0.0-beta.16",
-    "@allurereport/core-api": "3.0.0-beta.16",
-    "@allurereport/directory-watcher": "3.0.0-beta.16",
-    "@allurereport/plugin-allure2": "3.0.0-beta.16",
-    "@allurereport/plugin-api": "3.0.0-beta.16",
-    "@allurereport/plugin-awesome": "3.0.0-beta.16",
-    "@allurereport/plugin-classic": "3.0.0-beta.16",
-    "@allurereport/plugin-csv": "3.0.0-beta.16",
-    "@allurereport/plugin-dashboard": "3.0.0-beta.16",
-    "@allurereport/plugin-log": "3.0.0-beta.16",
-    "@allurereport/plugin-progress": "3.0.0-beta.16",
-    "@allurereport/plugin-server-reload": "3.0.0-beta.16",
-    "@allurereport/plugin-slack": "3.0.0-beta.16",
-    "@allurereport/reader-api": "3.0.0-beta.16",
-    "@allurereport/service": "3.0.0-beta.16",
-    "@allurereport/static-server": "3.0.0-beta.16",
-    "cac": "^6.7.14",
+    "@allurereport/core": "3.0.0-beta.18",
+    "@allurereport/core-api": "3.0.0-beta.18",
+    "@allurereport/directory-watcher": "3.0.0-beta.18",
+    "@allurereport/plugin-allure2": "3.0.0-beta.18",
+    "@allurereport/plugin-api": "3.0.0-beta.18",
+    "@allurereport/plugin-awesome": "3.0.0-beta.18",
+    "@allurereport/plugin-classic": "3.0.0-beta.18",
+    "@allurereport/plugin-csv": "3.0.0-beta.18",
+    "@allurereport/plugin-dashboard": "3.0.0-beta.18",
+    "@allurereport/plugin-log": "3.0.0-beta.18",
+    "@allurereport/plugin-progress": "3.0.0-beta.18",
+    "@allurereport/plugin-server-reload": "3.0.0-beta.18",
+    "@allurereport/plugin-slack": "3.0.0-beta.18",
+    "@allurereport/reader-api": "3.0.0-beta.18",
+    "@allurereport/service": "3.0.0-beta.18",
+    "@allurereport/static-server": "3.0.0-beta.18",
+    "adm-zip": "^0.5.16",
+    "clipanion": "^4.0.0-rc.4",
     "lodash.omit": "^4.5.0",
+    "picomatch": "^4.0.3",
     "prompts": "^2.4.2",
+    "terminate": "^2.8.0",
+    "typanion": "^3.14.0",
     "yoctocolors": "^2.1.1"
   },
   "devDependencies": {
     "@stylistic/eslint-plugin": "^2.6.1",
+    "@types/adm-zip": "^0",
     "@types/eslint": "^8.56.11",
     "@types/lodash.omit": "^4.5.9",
     "@types/node": "^20.17.9",
+    "@types/picomatch": "^4",
     "@types/prompts": "^2",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
     "@vitest/runner": "^2.1.9",
     "@vitest/snapshot": "^2.1.9",
-    "allure-vitest": "^3.0.9",
+    "allure-vitest": "^3.3.3",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.29.1",

package/dist/utils/commands.d.ts

@@ -1,16 +0,0 @@
-import type { CAC } from "cac";
-export type OptionDescription = [string] | [
-    string,
-    {
-        description?: string;
-        type?: any[];
-        default?: any;
-    }
-];
-export type CreateCommandOptions = {
-    name: string;
-    description?: string;
-    options?: OptionDescription[];
-    action: (...args: any[]) => Promise<void>;
-};
-export declare const createCommand: (payload: CreateCommandOptions) => (cli: CAC) => void;