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

package/dist/commands/projects/delete.js

@@ -1,74 +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 { createCommand } from "../../utils/commands.js";
 import { logError } from "../../utils/logs.js";
-export const ProjectsDeleteCommandAction = async (projectName, options) => {
-    const { force = false } = 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);
-    if (!projectName) {
-        console.error(red("No project name is provided"));
-        process.exit(1);
-        return;
-    }
-    if (!force) {
-        const res = await prompts({
-            type: "confirm",
-            name: "value",
-            message: `Are you sure you want to delete project "${projectName}"?`,
+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",
         });
-        if (!res.value) {
-            process.exit(0);
-            return;
-        }
-    }
-    try {
-        await serviceClient.deleteProject({
-            name: projectName,
+        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)",
         });
-        console.info(green("Project has been deleted"));
     }
-    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 delete project due to unexpected error", error);
-        process.exit(1);
+        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);
+        }
     }
-};
-export const ProjectsDeleteCommand = createCommand({
-    name: "project-delete <name>",
-    description: "",
-    options: [
-        [
-            "--force",
-            {
-                description: "Delete project with no confirmation",
-                default: false,
-            },
-        ],
-        [
-            "--config, -c <file>",
-            {
-                description: "The path Allure config file",
-            },
-        ],
-        [
-            "--cwd <cwd>",
-            {
-                description: "The working directory for the command to run (default: current working directory)",
-            },
-        ],
+}
+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"],
     ],
-    action: ProjectsDeleteCommandAction,
 });

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

@@ -1,7 +1,8 @@
-type CommandOptions = {
-    config?: string;
-    cwd?: string;
-};
-export declare const ProjectsListCommandAction: (options?: CommandOptions) => Promise<void>;
-export declare const ProjectsListCommand: (cli: import("cac").CAC) => void;
-export {};
+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>;
+}

package/dist/commands/projects/list.js

@@ -1,75 +1,75 @@
 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, yellow } from "yoctocolors";
-import { createCommand } from "../../utils/commands.js";
 import { logError } from "../../utils/logs.js";
-export const ProjectsListCommandAction = 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 ProjectsListCommand 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 projects = await serviceClient.projects();
-        if (projects.length === 0) {
-            console.info(yellow("No projects found. Create a new one with `allure project-create` command"));
+    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 res = await prompts({
-            type: "select",
-            name: "project",
-            message: "Select a project",
-            choices: projects.map((project) => ({
-                title: project.name,
-                value: project.name,
-            })),
-        });
-        if (!res?.project) {
-            console.error(red("No project selected"));
-            process.exit(1);
-            return;
+        const serviceClient = new AllureServiceClient(config.allureService);
+        try {
+            const projects = await serviceClient.projects();
+            if (projects.length === 0) {
+                console.info(yellow("No projects found. Create a new one with `allure project-create` command"));
+                return;
+            }
+            const res = await prompts({
+                type: "select",
+                name: "project",
+                message: "Select a project",
+                choices: projects.map((project) => ({
+                    title: project.name,
+                    value: project.name,
+                })),
+            });
+            if (!res?.project) {
+                console.error(red("No project selected"));
+                exit(1);
+                return;
+            }
+            const lines = [
+                "Insert following code into your Allure Config file, to enable Allure Service features for the project:",
+                "",
+                green("{"),
+                green("  allureService: {"),
+                green(`    project: "${res.project}"`),
+                green("  }"),
+                green("}"),
+            ];
+            console.info(lines.join("\n"));
         }
-        const lines = [
-            "Insert following code into your Allure Config file, to enable Allure Service features for the project:",
-            "",
-            green("{"),
-            green("  allureService: {"),
-            green(`    project: "${res.project}"`),
-            green("  }"),
-            green("}"),
-        ];
-        console.info(lines.join("\n"));
-    }
-    catch (error) {
-        if (error instanceof KnownError) {
-            console.error(red(error.message));
-            process.exit(1);
-            return;
+        catch (error) {
+            if (error instanceof KnownError) {
+                console.error(red(error.message));
+                exit(1);
+                return;
+            }
+            await logError("Failed to get projects due to unexpected error", error);
+            exit(1);
         }
-        await logError("Failed to get projects due to unexpected error", error);
-        process.exit(1);
     }
-};
-export const ProjectsListCommand = createCommand({
-    name: "projects",
+}
+ProjectsListCommand.paths = [["projects", "list"]];
+ProjectsListCommand.usage = Command.Usage({
+    category: "Allure Service Projects",
     description: "Shows list of all available projects for current user",
-    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)",
-            },
-        ],
-    ],
-    action: ProjectsListCommandAction,
+    details: "This command lists all available projects for the current user and allows selecting one to get configuration information.",
+    examples: [["projects list", "List all available projects"]],
 });

package/dist/commands/qualityGate.d.ts

@@ -1,7 +1,14 @@
-type QualityGateCommandOptions = {
-    config?: string;
-    cwd?: string;
-};
-export declare const QualityGateCommandAction: (resultsDir: string, options: QualityGateCommandOptions) => Promise<void>;
-export declare const QualityGateCommand: (cli: import("cac").CAC) => void;
-export {};
+import { Command } from "clipanion";
+export declare class QualityGateCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    resultsDir: string | undefined;
+    config: string | undefined;
+    fastFail: boolean | undefined;
+    maxFailures: number | undefined;
+    minTestsCount: number | undefined;
+    successRate: number | undefined;
+    knownIssues: string | undefined;
+    cwd: string | undefined;
+    execute(): Promise<void>;
+}

package/dist/commands/qualityGate.js

@@ -1,52 +1,138 @@
-import { AllureReport, readConfig } from "@allurereport/core";
-import console from "node:console";
-import process from "node:process";
-import { bold, red } from "yoctocolors";
-import { createCommand } from "../utils/commands.js";
-export const QualityGateCommandAction = async (resultsDir, options) => {
-    const { cwd, config: configPath } = options;
-    const fullConfig = await readConfig(cwd, configPath);
-    const allureReport = new AllureReport(fullConfig);
-    await allureReport.start();
-    await allureReport.readDirectory(resultsDir);
-    await allureReport.done();
-    await allureReport.validate();
-    if (allureReport.exitCode === 0) {
-        return;
+import { AllureReport, QualityGateState, readConfig, stringifyQualityGateResults } from "@allurereport/core";
+import { findMatching } from "@allurereport/directory-watcher";
+import { Command, Option } from "clipanion";
+import * as console from "node:console";
+import { realpath } from "node:fs/promises";
+import { join } from "node:path";
+import { exit, cwd as processCwd } from "node:process";
+import pm from "picomatch";
+import * as typanion from "typanion";
+import { red } from "yoctocolors";
+export class QualityGateCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.resultsDir = Option.String({
+            required: false,
+            name: "Pattern to match test results directories in the current working directory (default: ./**/allure-results)",
+        });
+        this.config = Option.String("--config,-c", {
+            description: "The path Allure config file",
+        });
+        this.fastFail = Option.Boolean("--fast-fail", {
+            description: "Force the command to fail if there are any rule failures",
+        });
+        this.maxFailures = Option.String("--max-failures", {
+            description: "The maximum number of rule failures to allow before failing the command",
+            validator: typanion.isNumber(),
+        });
+        this.minTestsCount = Option.String("--min-tests-count", {
+            description: "The minimum number of tests to run before validating the quality gate",
+            validator: typanion.isNumber(),
+        });
+        this.successRate = Option.String("--success-rate", {
+            description: "The minimum success rate to allow before failing the command",
+            validator: typanion.isNumber(),
+        });
+        this.knownIssues = Option.String("--known-issues", {
+            description: "Path to the known issues file. Updates the file and quarantines failed tests when specified",
+        });
+        this.cwd = Option.String("--cwd", {
+            description: "The working directory for the command to run (default: current working directory)",
+        });
     }
-    const failedResults = allureReport.validationResults.filter((result) => !result.success);
-    console.error(red(`Quality gate has failed with ${bold(failedResults.length.toString())} errors:\n`));
-    for (const result of failedResults) {
-        let scope = "";
-        switch (result.meta?.type) {
-            case "label":
-                scope = `(label[${result.meta.name}="${result.meta.value}"])`;
-                break;
-            case "parameter":
-                scope = `(parameter[${result.meta.name}="${result.meta.value}"])`;
-                break;
-        }
-        console.error(red(`⨯ ${bold(`${result.rule}${scope}`)}: expected ${result.expected}, actual ${result.actual}`));
+    async execute() {
+        const cwd = await realpath(this.cwd ?? processCwd());
+        const resultsDir = (this.resultsDir ?? "./**/allure-results").replace(/[\\/]$/, "");
+        const { maxFailures, minTestsCount, successRate, fastFail, knownIssues: knownIssuesPath } = this;
+        const config = await readConfig(cwd, this.config, {
+            knownIssuesPath,
+        });
+        const rules = {};
+        const resultsDirectories = new Set();
+        const matcher = pm(resultsDir, {
+            dot: true,
+            contains: true,
+        });
+        if (maxFailures !== undefined) {
+            rules.maxFailures = maxFailures;
+        }
+        if (minTestsCount !== undefined) {
+            rules.minTestsCount = minTestsCount;
+        }
+        if (successRate !== undefined) {
+            rules.successRate = successRate;
+        }
+        if (fastFail) {
+            rules.fastFail = fastFail;
+        }
+        config.plugins = [];
+        if (Object.keys(rules).length > 0) {
+            config.qualityGate = {
+                rules: [rules],
+            };
+        }
+        const allureReport = new AllureReport(config);
+        if (!allureReport.hasQualityGate) {
+            console.error(red("Quality gate is not configured!"));
+            console.error(red("Add qualityGate to the config or consult help to know, how to use the command with command-line arguments"));
+            exit(-1);
+            return;
+        }
+        await findMatching(cwd, resultsDirectories, (dirent) => {
+            if (dirent.isDirectory()) {
+                const fullPath = join(dirent?.parentPath ?? dirent?.path, dirent.name);
+                return matcher(fullPath);
+            }
+            return false;
+        });
+        if (resultsDirectories.size === 0) {
+            console.error("No Allure results directories found");
+            exit(0);
+            return;
+        }
+        const knownIssues = await allureReport.store.allKnownIssues();
+        const state = new QualityGateState();
+        allureReport.realtimeSubscriber.onTestResults(async (trsIds) => {
+            const trs = await Promise.all(trsIds.map((id) => allureReport.store.testResultById(id)));
+            const notHiddenTrs = trs.filter((tr) => !tr.hidden);
+            const { results, fastFailed } = await allureReport.validate({
+                trs: notHiddenTrs,
+                knownIssues,
+                state,
+            });
+            if (!fastFailed) {
+                return;
+            }
+            console.error(stringifyQualityGateResults(results));
+            exit(1);
+        });
+        await allureReport.start();
+        for (const dir of resultsDirectories) {
+            await allureReport.readDirectory(dir);
+        }
+        await allureReport.done();
+        const allTrs = await allureReport.store.allTestResults({ includeHidden: false });
+        const validationResults = await allureReport.validate({
+            trs: allTrs,
+            knownIssues,
+        });
+        if (validationResults.results.length === 0) {
+            exit(0);
+            return;
+        }
+        console.error(stringifyQualityGateResults(validationResults.results));
+        exit(1);
     }
-    console.error(red("\nThe process has been exited with code 1"));
-    process.exit(allureReport.exitCode);
-};
-export const QualityGateCommand = createCommand({
-    name: "quality-gate <resultsDir>",
+}
+QualityGateCommand.paths = [["quality-gate"]];
+QualityGateCommand.usage = Command.Usage({
     description: "Returns status code 1 if there any test failure above specified success rate",
-    options: [
-        [
-            "--config, -c <file>",
-            {
-                description: "The path Allure config file",
-            },
-        ],
+    details: "This command validates the test results against quality gates defined in the configuration.",
+    examples: [
+        ["quality-gate ./allure-results", "Validate the test results in the ./allure-results directory"],
         [
-            "--cwd <cwd>",
-            {
-                description: "The working directory for the command to run (Default: current working directory)",
-            },
+            "quality-gate ./allure-results --config custom-config.js",
+            "Validate the test results using a custom configuration file",
         ],
     ],
-    action: QualityGateCommandAction,
 });

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

@@ -0,0 +1,2 @@
+export * from "./pack.js";
+export * from "./unpack.js";

package/dist/commands/results/index.js

@@ -0,0 +1,2 @@
+export * from "./pack.js";
+export * from "./unpack.js";

package/dist/commands/results/pack.d.ts

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

package/dist/commands/results/pack.js

@@ -0,0 +1,111 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ResultsPackCommand_instances, _ResultsPackCommand_formatSize;
+import { findMatching } from "@allurereport/directory-watcher";
+import AdmZip from "adm-zip";
+import { Command, Option } from "clipanion";
+import * as console from "node:console";
+import * as fs from "node:fs/promises";
+import { realpath } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import pm from "picomatch";
+import { green, red } from "yoctocolors";
+export class ResultsPackCommand extends Command {
+    constructor() {
+        super(...arguments);
+        _ResultsPackCommand_instances.add(this);
+        this.resultsDir = Option.String({
+            required: false,
+            name: "Pattern to match test results directories in the current working directory (default: ./**/allure-results)",
+        });
+        this.name = Option.String("--name", {
+            description: "The archive name (default: allure-results.zip)",
+        });
+        this.cwd = Option.String("--cwd", {
+            description: "The working directory for the command to run (default: current working directory)",
+        });
+    }
+    async execute() {
+        const cwd = await realpath(this.cwd ?? process.cwd());
+        const resultsDir = (this.resultsDir ?? "./**/allure-results").replace(/[\\/]$/, "");
+        const archiveName = this.name ?? "allure-results.zip";
+        const resultsDirectories = new Set();
+        const resultsFiles = new Set();
+        const matcher = pm(resultsDir, {
+            dot: true,
+            contains: true,
+        });
+        await findMatching(cwd, resultsDirectories, (dirent) => {
+            if (dirent.isDirectory()) {
+                const fullPath = join(dirent?.parentPath ?? dirent?.path, dirent.name);
+                return matcher(fullPath);
+            }
+            return false;
+        });
+        if (resultsDirectories.size === 0) {
+            console.log(red(`No test results directories found matching pattern: ${resultsDir}`));
+            return;
+        }
+        for (const dir of resultsDirectories) {
+            const files = await fs.readdir(dir);
+            if (files.length === 0) {
+                continue;
+            }
+            for (const file of files) {
+                resultsFiles.add(resolve(dir, file));
+            }
+        }
+        const outputPath = join(cwd, archiveName);
+        const zip = new AdmZip();
+        for (const file of resultsFiles) {
+            try {
+                const stats = await fs.stat(file);
+                if (stats.isFile()) {
+                    zip.addLocalFile(file, "", basename(file));
+                }
+            }
+            catch (error) {
+                console.log(red(`Error adding file ${file} to archive: ${error.message}`));
+            }
+        }
+        try {
+            zip.writeZip(outputPath);
+            const stats = await fs.stat(outputPath);
+            console.log(green(`Archive created successfully: ${outputPath}`));
+            console.log(green(`Total size: ${__classPrivateFieldGet(this, _ResultsPackCommand_instances, "m", _ResultsPackCommand_formatSize).call(this, stats.size)}. ${resultsFiles.size} results files have been collected`));
+        }
+        catch (err) {
+            console.log(red(`Error creating archive: ${err.message}`));
+            throw err;
+        }
+    }
+}
+_ResultsPackCommand_instances = new WeakSet(), _ResultsPackCommand_formatSize = function _ResultsPackCommand_formatSize(bytes) {
+    const units = ["bytes", "KB", "MB", "GB"];
+    let size = bytes;
+    let unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+        size /= 1024;
+        unitIndex++;
+    }
+    if (bytes === 0) {
+        return "0 bytes";
+    }
+    return unitIndex === 0 ? `${Math.round(size)} ${units[unitIndex]}` : `${size.toFixed(2)} ${units[unitIndex]}`;
+};
+ResultsPackCommand.paths = [["results", "pack"]];
+ResultsPackCommand.usage = Command.Usage({
+    description: "Creates .zip archive with test results",
+    category: "Allure Test Results",
+    details: "This command creates .zip archive with all test results which can be collected in the project",
+    examples: [
+        ["results pack", "Creates .zip archive with test results in directories matched to ./**/allure-results pattern"],
+        [
+            "results pack ./**/foo/**/my-results --name results.zip",
+            "Creates results.zip archive with test results in directories matched to ./**/foo/**/my-results pattern",
+        ],
+    ],
+});

package/dist/commands/results/unpack.d.ts

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