allure 3.0.0-beta.2 → 3.0.0-beta.20

package/dist/commands/watch.js

@@ -1,118 +1,122 @@
-import { AllureReport, isFileNotFoundError, readRuntimeConfig } from "@allure/core";
-import { newFilesInDirectoryWatcher } from "@allure/directory-watcher";
-import AllureAwesome from "@allure/plugin-awesome";
-import ProgressPlugin from "@allure/plugin-progress";
-import ServerReloadPlugin from "@allure/plugin-server-reload";
-import { PathResultFile } from "@allure/reader-api";
-import { serve } from "@allure/static-server";
+import { AllureReport, isFileNotFoundError, readConfig } from "@allurereport/core";
+import { newFilesInDirectoryWatcher } from "@allurereport/directory-watcher";
+import Awesome from "@allurereport/plugin-awesome";
+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 readRuntimeConfig(configPath, cwd, output, 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) : 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 AllureAwesome({
-                            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

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

@@ -0,0 +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 { logError } from "../utils/logs.js";
+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)",
+        });
+    }
+    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 {
+            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);
+        }
+    }
+}
+WhoamiCommand.paths = [["whoami"]];
+WhoamiCommand.usage = Command.Usage({
+    category: "Allure Service",
+    description: "Prints information about current user",
+    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"],
+        [
+            "whoami --config custom-config.js",
+            "Print information about the current user using a custom configuration file",
+        ],
+    ],
+});

package/dist/index.d.ts

@@ -1,2 +1 @@
-import { defineConfig } from "@allure/core";
-export { defineConfig };
+export { defineConfig, defaultChartsConfig } from "@allurereport/plugin-api";

package/dist/index.js

@@ -1,33 +1,39 @@
-import { defineConfig } from "@allure/core";
-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 { ClassicCommand, AwesomeCommand, CsvCommand, GenerateCommand, HistoryCommand, KnownIssueCommand, LogCommand, OpenCommand, QualityGateCommand, RunCommand, SlackCommand, TestPlanCommand, WatchCommand, } 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,
-    AwesomeCommand,
-    CsvCommand,
-    GenerateCommand,
-    HistoryCommand,
-    KnownIssueCommand,
-    LogCommand,
-    OpenCommand,
-    QualityGateCommand,
-    RunCommand,
-    SlackCommand,
-    TestPlanCommand,
-    WatchCommand,
-];
-commands.forEach((command) => {
-    command(cli);
-});
-cli.on("command:*", () => {
-    console.error("Invalid command: %s", cli.args.join(" "));
-    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 };
+export { defineConfig, defaultChartsConfig } from "@allurereport/plugin-api";

package/dist/utils/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./process.js";
 export * from "./terminal.js";
+export * from "./logs.js";

package/dist/utils/index.js

@@ -1,2 +1,3 @@
 export * from "./process.js";
 export * from "./terminal.js";
+export * from "./logs.js";

package/dist/utils/logs.d.ts

@@ -0,0 +1,3 @@
+export declare const getLogFileName: () => string;
+export declare const readLogs: () => Promise<string>;
+export declare const logError: (message: string, error: Error) => Promise<void>;

package/dist/utils/logs.js

@@ -0,0 +1,32 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { red } from "yoctocolors";
+const LOGS_DIRECTORY = join(homedir(), ".allure", "logs");
+export const getLogFileName = () => `${new Date().toISOString().replace(/:/g, "-")}.log`;
+export const readLogs = async () => {
+    await mkdir(LOGS_DIRECTORY, { recursive: true });
+    const logFilePath = join(LOGS_DIRECTORY, getLogFileName());
+    try {
+        const logs = await readFile(logFilePath, "utf-8");
+        return logs;
+    }
+    catch (err) {
+        return "";
+    }
+};
+export const logError = async (message, error) => {
+    let logs = await readLogs();
+    if (!logs) {
+        logs += `${new Date().toISOString()}[ERROR] ${error.message}\n`;
+    }
+    else {
+        logs += `\n${new Date().toISOString()}[ERROR] ${error.message}\n`;
+    }
+    if (error.stack) {
+        logs += `${error.stack}\n`;
+    }
+    const logFilePath = join(LOGS_DIRECTORY, getLogFileName());
+    await writeFile(logFilePath, logs, "utf-8");
+    console.error(red(`${message}. Check logs for more details: ${logFilePath}`));
+};

package/dist/utils/process.d.ts

@@ -1,3 +1,9 @@
-import { ChildProcess } from "node:child_process";
-export declare const runProcess: (command: string, commandArgs: string[], cwd: string | undefined, environment: Record<string, string>, silent?: boolean) => ChildProcess;
+import type { ChildProcess } from "node:child_process";
+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/dist/utils/terminal.d.ts

@@ -1,3 +1,3 @@
-import { TestResult, TestStatus } from "@allure/core-api";
+import type { TestResult, TestStatus } from "@allurereport/core-api";
 export declare const status2color: (status: TestStatus) => import("yoctocolors").Format;
 export declare const logTests: (testResults: TestResult[]) => void;

package/dist/utils/terminal.js

@@ -1,4 +1,4 @@
-import { formatDuration } from "@allure/core-api";
+import { formatDuration } from "@allurereport/core-api";
 import console from "node:console";
 import { blue, gray, green, red, yellow } from "yoctocolors";
 export const status2color = (status) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allure",
-  "version": "3.0.0-beta.2",
+  "version": "3.0.0-beta.20",
   "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",
@@ -24,32 +25,49 @@
   "scripts": {
     "build": "run clean && tsc --project ./tsconfig.json",
     "clean": "rimraf ./dist",
+    "eslint": "eslint ./src/**/*.{js,jsx,ts,tsx}",
+    "eslint:format": "eslint --fix ./src/**/*.{js,jsx,ts,tsx}",
     "start": "node ./cli.js",
     "test": "vitest run"
   },
   "dependencies": {
-    "@allure/core": "3.0.0-beta.2",
-    "@allure/core-api": "3.0.0-beta.2",
-    "@allure/directory-watcher": "3.0.0-beta.2",
-    "@allure/plugin-awesome": "3.0.0-beta.2",
-    "@allure/plugin-progress": "3.0.0-beta.2",
-    "@allure/plugin-server-reload": "3.0.0-beta.2",
-    "@allure/plugin-slack": "3.0.0-beta.2",
-    "@allure/reader-api": "3.0.0-beta.2",
-    "@allure/static-server": "3.0.0-beta.2",
-    "cac": "^6.7.14",
+    "@allurereport/core": "3.0.0-beta.20",
+    "@allurereport/core-api": "3.0.0-beta.20",
+    "@allurereport/directory-watcher": "3.0.0-beta.20",
+    "@allurereport/plugin-allure2": "3.0.0-beta.20",
+    "@allurereport/plugin-api": "3.0.0-beta.20",
+    "@allurereport/plugin-awesome": "3.0.0-beta.20",
+    "@allurereport/plugin-classic": "3.0.0-beta.20",
+    "@allurereport/plugin-csv": "3.0.0-beta.20",
+    "@allurereport/plugin-dashboard": "3.0.0-beta.20",
+    "@allurereport/plugin-log": "3.0.0-beta.20",
+    "@allurereport/plugin-progress": "3.0.0-beta.20",
+    "@allurereport/plugin-server-reload": "3.0.0-beta.20",
+    "@allurereport/plugin-slack": "3.0.0-beta.20",
+    "@allurereport/reader-api": "3.0.0-beta.20",
+    "@allurereport/service": "3.0.0-beta.20",
+    "@allurereport/static-server": "3.0.0-beta.20",
+    "adm-zip": "^0.5.16",
+    "clipanion": "^4.0.0-rc.4",
+    "glob": "^11.0.3",
     "lodash.omit": "^4.5.0",
+    "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/prompts": "^2",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
-    "@vitest/runner": "^2.1.8",
-    "allure-vitest": "^3.0.7",
+    "@vitest/runner": "^2.1.9",
+    "@vitest/snapshot": "^2.1.9",
+    "allure-vitest": "^3.3.3",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.29.1",
@@ -59,6 +77,6 @@
     "eslint-plugin-prefer-arrow": "^1.2.3",
     "rimraf": "^6.0.1",
     "typescript": "^5.6.3",
-    "vitest": "^2.1.8"
+    "vitest": "^2.1.9"
   }
 }

package/dist/utils/commands.d.ts

@@ -1,16 +0,0 @@
-import { 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;

package/dist/utils/commands.js

@@ -1,14 +0,0 @@
-export const createCommand = (payload) => {
-    if (!payload.name)
-        throw new Error("Command name is not provided!");
-    if (!payload.action)
-        throw new Error("Command action is not provided!");
-    return (cli) => {
-        const command = cli.command(payload.name, payload.description);
-        payload?.options?.forEach(([name, parameters]) => {
-            const { description = "", ...rest } = parameters || {};
-            command.option(name, description, rest);
-        });
-        command.action(payload.action);
-    };
-};