allure 3.0.0-beta.17 → 3.0.0-beta.19

package/dist/commands/generate.d.ts

@@ -2,10 +2,11 @@ import { Command } from "clipanion";
 export declare class GenerateCommand extends Command {
     static paths: string[][];
     static usage: import("clipanion").Usage;
-    resultsDir: string;
+    resultsDir: string | undefined;
     config: string | undefined;
     output: string | undefined;
     cwd: string | undefined;
     reportName: string | undefined;
+    stage: string[] | undefined;
     execute(): Promise<void>;
 }

package/dist/commands/generate.js

@@ -1,13 +1,19 @@
 import { AllureReport, readConfig } from "@allurereport/core";
 import { KnownError } from "@allurereport/service";
 import { Command, Option } from "clipanion";
-import process from "node:process";
+import { glob } from "glob";
+import * as console from "node:console";
+import { sep } from "node:path";
+import { exit, cwd as processCwd } from "node:process";
 import { red } from "yoctocolors";
 import { logError } from "../utils/logs.js";
 export class GenerateCommand extends Command {
     constructor() {
         super(...arguments);
-        this.resultsDir = Option.String({ required: true, name: "The directory with Allure results" });
+        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",
         });
@@ -18,28 +24,65 @@ export class GenerateCommand extends Command {
             description: "The working directory for the command to run (default: current working directory)",
         });
         this.reportName = Option.String("--report-name,--name", {
-            description: "The report name",
+            description: "The report name (default: Allure Report)",
+        });
+        this.stage = Option.Array("--stage", {
+            description: "Stages archives to restore state from (default: empty string)",
         });
     }
     async execute() {
-        const config = await readConfig(this.cwd, this.config, {
+        const cwd = this.cwd ?? processCwd();
+        const resultsDir = (this.resultsDir ?? "./**/allure-results").replace(/[\\/]$/, "");
+        const config = await readConfig(cwd, this.config, {
             name: this.reportName,
             output: this.output ?? "allure-report",
         });
+        const stageDumpFiles = [];
+        const resultsDirectories = [];
+        if (this.stage?.length) {
+            for (const stage of this.stage) {
+                const matchedFiles = await glob(stage, {
+                    nodir: true,
+                    dot: true,
+                    absolute: true,
+                    windowsPathsNoEscape: true,
+                    cwd,
+                });
+                stageDumpFiles.push(...matchedFiles);
+            }
+        }
+        if (!!this.resultsDir || stageDumpFiles.length === 0) {
+            const matchedDirs = (await glob(resultsDir, {
+                mark: true,
+                nodir: false,
+                absolute: true,
+                dot: true,
+                windowsPathsNoEscape: true,
+                cwd,
+            })).filter((p) => p.endsWith(sep));
+            resultsDirectories.push(...matchedDirs);
+        }
+        if (resultsDirectories.length === 0 && stageDumpFiles.length === 0) {
+            console.log(red(`No test results directories found matching pattern: ${resultsDir}`));
+            return;
+        }
         try {
             const allureReport = new AllureReport(config);
+            await allureReport.restoreState(Array.from(stageDumpFiles));
             await allureReport.start();
-            await allureReport.readDirectory(this.resultsDir);
+            for (const dir of resultsDirectories) {
+                await allureReport.readDirectory(dir);
+            }
             await allureReport.done();
         }
         catch (error) {
             if (error instanceof KnownError) {
                 console.error(red(error.message));
-                process.exit(1);
+                exit(1);
                 return;
             }
             await logError("Failed to generate report due to unexpected error", error);
-            process.exit(1);
+            exit(1);
         }
     }
 }
@@ -53,5 +96,13 @@ GenerateCommand.usage = Command.Usage({
             "generate ./allure-results --output custom-report",
             "Generate a report from the ./allure-results directory to the custom-report directory",
         ],
+        [
+            "generate --stage=windows.zip --stage=macos.zip ./allure-results",
+            "Generate a report using data from windows.zip and macos.zip archives and using results from the ./allure-results directory",
+        ],
+        [
+            "generate --stage=allure-*.zip",
+            "Generate a report using data from any stage archive that matches the given pattern only (ignoring results directories)",
+        ],
     ],
 });

package/dist/commands/index.d.ts

@@ -19,3 +19,4 @@ export * from "./login.js";
 export * from "./logout.js";
 export * from "./whoami.js";
 export * from "./projects/index.js";
+export * from "./results/index.js";

package/dist/commands/index.js

@@ -19,3 +19,4 @@ export * from "./login.js";
 export * from "./logout.js";
 export * from "./whoami.js";
 export * from "./projects/index.js";
+export * from "./results/index.js";

package/dist/commands/projects/create.js

@@ -77,7 +77,7 @@ ProjectsCreateCommand.usage = Command.Usage({
     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"],
+        ["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.js

@@ -62,7 +62,7 @@ ProjectsDeleteCommand.usage = Command.Usage({
     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"],
+        ["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/list.js

@@ -71,5 +71,5 @@ ProjectsListCommand.usage = Command.Usage({
     category: "Allure Service Projects",
     description: "Shows list of all available projects for current user",
     details: "This command lists all available projects for the current user and allows selecting one to get configuration information.",
-    examples: [["projects", "List all available projects"]],
+    examples: [["projects list", "List all available projects"]],
 });

package/dist/commands/qualityGate.d.ts

@@ -2,8 +2,13 @@ import { Command } from "clipanion";
 export declare class QualityGateCommand extends Command {
     static paths: string[][];
     static usage: import("clipanion").Usage;
-    resultsDir: string;
+    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,45 +1,122 @@
-import { AllureReport, readConfig } from "@allurereport/core";
+import { AllureReport, QualityGateState, readConfig, stringifyQualityGateResults } from "@allurereport/core";
 import { Command, Option } from "clipanion";
+import { glob } from "glob";
 import * as console from "node:console";
-import { exit } from "node:process";
-import { bold, red } from "yoctocolors";
+import { realpath } from "node:fs/promises";
+import { sep } from "node:path";
+import { exit, cwd as processCwd } from "node:process";
+import * as typanion from "typanion";
+import { red } from "yoctocolors";
 export class QualityGateCommand extends Command {
     constructor() {
         super(...arguments);
-        this.resultsDir = Option.String({ required: true, name: "The directory with Allure results" });
+        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)",
         });
     }
     async execute() {
-        const fullConfig = await readConfig(this.cwd, this.config);
-        const allureReport = new AllureReport(fullConfig);
-        await allureReport.start();
-        await allureReport.readDirectory(this.resultsDir);
-        await allureReport.done();
-        await allureReport.validate();
-        if (allureReport.exitCode === 0) {
+        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 = {};
+        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;
         }
-        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;
+        const resultsDirectories = (await glob(resultsDir, {
+            mark: true,
+            nodir: false,
+            absolute: true,
+            dot: true,
+            windowsPathsNoEscape: true,
+            cwd,
+        })).filter((p) => p.endsWith(sep));
+        if (resultsDirectories.length === 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(red(`⨯ ${bold(`${result.rule}${scope}`)}: expected ${result.expected}, actual ${result.actual}`));
+            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(red("\nThe process has been exited with code 1"));
-        exit(allureReport.exitCode);
+        console.error(stringifyQualityGateResults(validationResults.results));
+        exit(1);
     }
 }
 QualityGateCommand.paths = [["quality-gate"]];

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,106 @@
+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 AdmZip from "adm-zip";
+import { Command, Option } from "clipanion";
+import { glob } from "glob";
+import * as console from "node:console";
+import * as fs from "node:fs/promises";
+import { realpath } from "node:fs/promises";
+import { basename, join, resolve, sep } from "node:path";
+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 = (await glob(resultsDir, {
+            mark: true,
+            nodir: false,
+            dot: true,
+            absolute: true,
+            windowsPathsNoEscape: true,
+            cwd,
+        })).filter((p) => p.endsWith(sep));
+        const resultsFiles = new Set();
+        if (resultsDirectories.length === 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>;
+}

package/dist/commands/results/unpack.js

@@ -0,0 +1,79 @@
+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, resolve } from "node:path";
+import { green, red } from "yoctocolors";
+export class ResultsUnpackCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.output = Option.String("--output", "./allure-results", {
+            description: "Output directory where the archives should be unarchived to (default: ./allure-results)",
+        });
+        this.archives = Option.Rest({
+            name: "List of test results archives to extract separated by spaces. If no archives are provided, the command will extract allure-results.zip archive",
+        });
+        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 outputDir = resolve(cwd, this.output);
+        const archives = this.archives.length > 0 ? this.archives : ["allure-results.zip"];
+        try {
+            await fs.mkdir(outputDir, { recursive: true });
+        }
+        catch (ignored) { }
+        let successCount = 0;
+        let failCount = 0;
+        for (const archivePath of archives) {
+            const resolvedPath = resolve(cwd, archivePath);
+            try {
+                await fs.access(resolvedPath);
+                console.log(`Extracting ${resolvedPath} to ${outputDir}`);
+                try {
+                    const zip = new AdmZip(resolvedPath);
+                    zip.extractAllTo(outputDir, true);
+                    console.log(green(`Successfully extracted ${basename(resolvedPath)}`));
+                    successCount++;
+                }
+                catch (err) {
+                    console.log(red(`Error extracting ${basename(resolvedPath)}: ${err.message}`));
+                    failCount++;
+                }
+            }
+            catch (error) {
+                console.log(red(`Error accessing archive ${resolvedPath}: ${error.message}`));
+                failCount++;
+            }
+        }
+        console.log(green(`Extraction complete. Successfully extracted ${successCount} archive(s).`));
+        if (failCount > 0) {
+            console.log(red(`Failed to extract ${failCount} archive(s).`));
+            return;
+        }
+    }
+}
+ResultsUnpackCommand.paths = [["results", "unpack"]];
+ResultsUnpackCommand.usage = Command.Usage({
+    description: "Extracts test results from .zip archives",
+    category: "Allure Test Results",
+    details: "This command extracts test results from .zip archives to the specified output directory",
+    examples: [
+        ["results unpack", "Extract test results from allure-results.zip to the default directory (./allure-results)"],
+        [
+            "results unpack results.zip",
+            "Extract test results from results.zip to the default directory (./allure-results)",
+        ],
+        [
+            "results unpack results1.zip results2.zip results3.zip",
+            "Extract test results from multiple archives to the default directory",
+        ],
+        [
+            "results unpack --output ./mydir results1.zip results2.zip results3.zip",
+            "Extract test results from multiple archives to the specified directory (./mydir)",
+        ],
+    ],
+});

package/dist/commands/run.d.ts

@@ -1,4 +1,11 @@
+import type { QualityGateValidationResult } from "@allurereport/plugin-api";
 import { Command } from "clipanion";
+export type TestProcessResult = {
+    code: number | null;
+    stdout: string;
+    stderr: string;
+    qualityGateResults: QualityGateValidationResult[];
+};
 export declare class RunCommand extends Command {
     static paths: string[][];
     static usage: import("clipanion").Usage;
@@ -8,6 +15,10 @@ export declare class RunCommand extends Command {
     reportName: string | undefined;
     rerun: string | undefined;
     silent: boolean | undefined;
+    ignoreLogs: boolean | undefined;
+    stage: string | undefined;
+    environment: string | undefined;
     commandToRun: string[];
+    get logs(): "pipe" | "inherit" | "ignore";
     execute(): Promise<void>;
 }

package/dist/commands/run.js

@@ -1,19 +1,21 @@
-import { AllureReport, isFileNotFoundError, readConfig } from "@allurereport/core";
+import { AllureReport, QualityGateState, isFileNotFoundError, readConfig, stringifyQualityGateResults, } from "@allurereport/core";
 import { createTestPlan } from "@allurereport/core-api";
 import { allureResultsDirectoriesWatcher, delayedFileProcessingWatcher, newFilesInDirectoryWatcher, } from "@allurereport/directory-watcher";
 import Awesome from "@allurereport/plugin-awesome";
-import { PathResultFile } from "@allurereport/reader-api";
+import { BufferResultFile, PathResultFile } from "@allurereport/reader-api";
 import { KnownError } from "@allurereport/service";
 import { Command, Option } from "clipanion";
 import * as console from "node:console";
 import { mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
-import process from "node:process";
+import process, { exit } from "node:process";
+import terminate from "terminate/promise";
 import { red } from "yoctocolors";
 import { logTests, runProcess, terminationOf } from "../utils/index.js";
 import { logError } from "../utils/logs.js";
-const runTests = async (allureReport, cwd, command, commandArgs, environment, silent) => {
+const runTests = async (params) => {
+    const { allureReport, knownIssues, cwd, command, commandArgs, logs, environment, withQualityGate, silent } = params;
     let testProcessStarted = false;
     const allureResultsWatchers = new Map();
     const processWatcher = delayedFileProcessingWatcher(async (path) => {
@@ -47,17 +49,83 @@ const runTests = async (allureReport, cwd, command, commandArgs, environment, si
     await allureResultsWatch.initialScan();
     testProcessStarted = true;
     const beforeProcess = Date.now();
-    const testProcess = runProcess(command, commandArgs, cwd, environment, silent);
+    const testProcess = runProcess({
+        command,
+        commandArgs,
+        cwd,
+        environment,
+        logs,
+    });
+    const qualityGateState = new QualityGateState();
+    let qualityGateUnsub;
+    let qualityGateResults = [];
+    let testProcessStdout = "";
+    let testProcessStderr = "";
+    if (withQualityGate) {
+        qualityGateUnsub = allureReport.realtimeSubscriber.onTestResults(async (testResults) => {
+            const trs = await Promise.all(testResults.map((tr) => allureReport.store.testResultById(tr)));
+            const filteredTrs = trs.filter((tr) => tr !== undefined);
+            if (!filteredTrs.length) {
+                return;
+            }
+            const { results, fastFailed } = await allureReport.validate({
+                trs: filteredTrs,
+                state: qualityGateState,
+                knownIssues,
+            });
+            if (!fastFailed) {
+                return;
+            }
+            allureReport.realtimeDispatcher.sendQualityGateResults(results);
+            qualityGateResults = results;
+            try {
+                await terminate(testProcess.pid, "SIGTERM");
+            }
+            catch (err) {
+                if (err.message.includes("kill ESRCH")) {
+                    return;
+                }
+                throw err;
+            }
+        });
+    }
+    if (logs === "pipe") {
+        testProcess.stdout?.setEncoding("utf8").on?.("data", (data) => {
+            testProcessStdout += data;
+            if (silent) {
+                return;
+            }
+            process.stdout.write(data);
+        });
+        testProcess.stderr?.setEncoding("utf8").on?.("data", async (data) => {
+            testProcessStderr += data;
+            if (silent) {
+                return;
+            }
+            process.stderr.write(data);
+        });
+    }
     const code = await terminationOf(testProcess);
     const afterProcess = Date.now();
-    console.log(`process finished with code ${code ?? 0} (${afterProcess - beforeProcess})ms`);
+    if (code !== null) {
+        console.log(`process finished with code ${code} (${afterProcess - beforeProcess}ms)`);
+    }
+    else {
+        console.log(`process terminated (${afterProcess - beforeProcess}ms)`);
+    }
     await allureResultsWatch.abort();
     for (const [ar, watcher] of allureResultsWatchers) {
         await watcher.abort();
         allureResultsWatchers.delete(ar);
     }
     await processWatcher.abort();
-    return code;
+    qualityGateUnsub?.();
+    return {
+        code,
+        stdout: testProcessStdout,
+        stderr: testProcessStderr,
+        qualityGateResults,
+    };
 };
 export class RunCommand extends Command {
     constructor() {
@@ -80,7 +148,22 @@ export class RunCommand extends Command {
         this.silent = Option.Boolean("--silent", {
             description: "Don't pipe the process output logs to console (default: 0)",
         });
-        this.commandToRun = Option.Proxy();
+        this.ignoreLogs = Option.Boolean("--ignore-logs", {
+            description: "Prevent logs attaching to the report (default: false)",
+        });
+        this.stage = Option.String("--stage", {
+            description: "Runs tests in stage mode to collect results to a stage archive with the provided name (default: empty string)",
+        });
+        this.environment = Option.String("--environment", {
+            description: "Force specific environment to all tests in the run. Given environment has higher priority than the one defined in the config file (default: empty string)",
+        });
+        this.commandToRun = Option.Rest();
+    }
+    get logs() {
+        if (this.silent) {
+            return this.ignoreLogs ? "ignore" : "pipe";
+        }
+        return this.ignoreLogs ? "inherit" : "pipe";
     }
     async execute() {
         const args = this.commandToRun.filter((arg) => arg !== "--");
@@ -97,8 +180,14 @@ export class RunCommand extends Command {
         const cwd = await realpath(this.cwd ?? process.cwd());
         console.log(`${command} ${commandArgs.join(" ")}`);
         const maxRerun = this.rerun ? parseInt(this.rerun, 10) : 0;
-        const silent = this.silent ?? false;
         const config = await readConfig(cwd, this.config, { output: this.output, name: this.reportName });
+        const withQualityGate = !!config.qualityGate;
+        const withRerun = !!this.rerun;
+        if (withQualityGate && withRerun) {
+            console.error(red("At this moment, quality gate and rerun can't be used at the same time!"));
+            console.error(red("Consider using --rerun=0 or disable quality gate in the config to run tests"));
+            exit(-1);
+        }
         try {
             await rm(config.output, { recursive: true });
         }
@@ -107,27 +196,46 @@ export class RunCommand extends Command {
                 console.error("could not clean output directory", e);
             }
         }
+        const allureReport = new AllureReport({
+            ...config,
+            environment: this.environment,
+            stage: this.stage,
+            realTime: false,
+            plugins: [
+                ...(config.plugins?.length
+                    ? config.plugins
+                    : [
+                        {
+                            id: "awesome",
+                            enabled: true,
+                            options: {},
+                            plugin: new Awesome({
+                                reportName: config.name,
+                            }),
+                        },
+                    ]),
+            ],
+        });
+        const knownIssues = await allureReport.store.allKnownIssues();
+        await allureReport.start();
+        const globalExitCode = {
+            original: 0,
+            actual: undefined,
+        };
+        let qualityGateResults;
+        let testProcessResult = null;
         try {
-            const allureReport = new AllureReport({
-                ...config,
-                realTime: false,
-                plugins: [
-                    ...(config.plugins?.length
-                        ? config.plugins
-                        : [
-                            {
-                                id: "awesome",
-                                enabled: true,
-                                options: {},
-                                plugin: new Awesome({
-                                    reportName: config.name,
-                                }),
-                            },
-                        ]),
-                ],
+            testProcessResult = await runTests({
+                logs: this.logs,
+                silent: this.silent,
+                allureReport,
+                knownIssues,
+                cwd,
+                command,
+                commandArgs,
+                environment: {},
+                withQualityGate,
             });
-            await allureReport.start();
-            let code = await runTests(allureReport, cwd, command, commandArgs, {}, silent);
             for (let rerun = 0; rerun < maxRerun; rerun++) {
                 const failed = await allureReport.store.failedTestResults();
                 if (failed.length === 0) {
@@ -140,26 +248,78 @@ export class RunCommand extends Command {
                 const tmpDir = await mkdtemp(join(tmpdir(), "allure-run-"));
                 const testPlanPath = resolve(tmpDir, `${rerun}-testplan.json`);
                 await writeFile(testPlanPath, JSON.stringify(testPlan));
-                code = await runTests(allureReport, cwd, command, commandArgs, {
-                    ALLURE_TESTPLAN_PATH: testPlanPath,
-                    ALLURE_RERUN: `${rerun}`,
-                }, silent);
+                testProcessResult = await runTests({
+                    silent: this.silent,
+                    logs: this.logs,
+                    allureReport,
+                    knownIssues,
+                    cwd,
+                    command,
+                    commandArgs,
+                    environment: {
+                        ALLURE_TESTPLAN_PATH: testPlanPath,
+                        ALLURE_RERUN: `${rerun}`,
+                    },
+                    withQualityGate,
+                });
                 await rm(tmpDir, { recursive: true });
                 logTests(await allureReport.store.allTestResults());
             }
-            await allureReport.done();
-            await allureReport.validate();
-            process.exit(code ?? allureReport.exitCode);
+            const trs = await allureReport.store.allTestResults({ includeHidden: false });
+            qualityGateResults = testProcessResult?.qualityGateResults ?? [];
+            if (withQualityGate && !qualityGateResults?.length) {
+                const { results } = await allureReport.validate({
+                    trs,
+                    knownIssues,
+                });
+                qualityGateResults = results;
+            }
+            if (qualityGateResults?.length) {
+                const qualityGateMessage = stringifyQualityGateResults(qualityGateResults);
+                console.error(qualityGateMessage);
+                allureReport.realtimeDispatcher.sendQualityGateResults(qualityGateResults);
+            }
+            globalExitCode.original = testProcessResult?.code ?? -1;
+            if (withQualityGate) {
+                globalExitCode.actual = qualityGateResults.length > 0 ? 1 : 0;
+            }
         }
         catch (error) {
+            globalExitCode.actual = 1;
             if (error instanceof KnownError) {
                 console.error(red(error.message));
-                process.exit(1);
-                return;
+                allureReport.realtimeDispatcher.sendGlobalError({
+                    message: error.message,
+                });
+            }
+            else {
+                await logError("Failed to run tests using Allure due to unexpected error", error);
+                allureReport.realtimeDispatcher.sendGlobalError({
+                    message: error.message,
+                    trace: error.stack,
+                });
+            }
+        }
+        const processFailed = Math.abs(globalExitCode.actual ?? globalExitCode.original) !== 0;
+        if (!this.ignoreLogs && testProcessResult?.stdout) {
+            const stdoutResultFile = new BufferResultFile(Buffer.from(testProcessResult.stdout, "utf8"), "stdout.txt");
+            stdoutResultFile.contentType = "text/plain";
+            allureReport.realtimeDispatcher.sendGlobalAttachment(stdoutResultFile);
+        }
+        if (!this.ignoreLogs && testProcessResult?.stderr) {
+            const stderrResultFile = new BufferResultFile(Buffer.from(testProcessResult.stderr, "utf8"), "stderr.txt");
+            stderrResultFile.contentType = "text/plain";
+            allureReport.realtimeDispatcher.sendGlobalAttachment(stderrResultFile);
+            if (processFailed) {
+                allureReport.realtimeDispatcher.sendGlobalError({
+                    message: "Test process has failed",
+                    trace: testProcessResult.stderr,
+                });
             }
-            await logError("Failed to run tests using Allure due to unexpected error", error);
-            process.exit(1);
         }
+        allureReport.realtimeDispatcher.sendGlobalExitCode(globalExitCode);
+        await allureReport.done();
+        exit(globalExitCode.actual ?? globalExitCode.original);
     }
 }
 RunCommand.paths = [["run"]];
@@ -169,5 +329,9 @@ RunCommand.usage = Command.Usage({
     examples: [
         ["run -- npm run test", "Run npm run test and collect Allure results"],
         ["run --rerun 3 -- npm run test", "Run npm run test and rerun failed tests up to 3 times"],
+        [
+            "run --stage=my-stage -- npm run test",
+            "Run npm run test and pack inner report state into my-stage.zip archive to restore the state in the next run",
+        ],
     ],
 });

package/dist/index.d.ts

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

package/dist/index.js

@@ -2,7 +2,7 @@ import { Builtins, Cli } from "clipanion";
 import console from "node:console";
 import { readFileSync } from "node:fs";
 import { argv, cwd } from "node:process";
-import { Allure2Command, AwesomeCommand, ClassicCommand, CsvCommand, DashboardCommand, GenerateCommand, HistoryCommand, KnownIssueCommand, LogCommand, LoginCommand, LogoutCommand, OpenCommand, ProjectsCreateCommand, ProjectsDeleteCommand, ProjectsListCommand, QualityGateCommand, RunCommand, SlackCommand, TestPlanCommand, WatchCommand, WhoamiCommand, } from "./commands/index.js";
+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 = new Cli({
@@ -31,7 +31,9 @@ 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());
-export { defineConfig } from "@allurereport/plugin-api";
+export { defineConfig, defaultChartsConfig } 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.17",
+  "version": "3.0.0-beta.19",
   "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,29 +31,34 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@allurereport/core": "3.0.0-beta.17",
-    "@allurereport/core-api": "3.0.0-beta.17",
-    "@allurereport/directory-watcher": "3.0.0-beta.17",
-    "@allurereport/plugin-allure2": "3.0.0-beta.17",
-    "@allurereport/plugin-api": "3.0.0-beta.17",
-    "@allurereport/plugin-awesome": "3.0.0-beta.17",
-    "@allurereport/plugin-classic": "3.0.0-beta.17",
-    "@allurereport/plugin-csv": "3.0.0-beta.17",
-    "@allurereport/plugin-dashboard": "3.0.0-beta.17",
-    "@allurereport/plugin-log": "3.0.0-beta.17",
-    "@allurereport/plugin-progress": "3.0.0-beta.17",
-    "@allurereport/plugin-server-reload": "3.0.0-beta.17",
-    "@allurereport/plugin-slack": "3.0.0-beta.17",
-    "@allurereport/reader-api": "3.0.0-beta.17",
-    "@allurereport/service": "3.0.0-beta.17",
-    "@allurereport/static-server": "3.0.0-beta.17",
+    "@allurereport/core": "3.0.0-beta.19",
+    "@allurereport/core-api": "3.0.0-beta.19",
+    "@allurereport/directory-watcher": "3.0.0-beta.19",
+    "@allurereport/plugin-allure2": "3.0.0-beta.19",
+    "@allurereport/plugin-api": "3.0.0-beta.19",
+    "@allurereport/plugin-awesome": "3.0.0-beta.19",
+    "@allurereport/plugin-classic": "3.0.0-beta.19",
+    "@allurereport/plugin-csv": "3.0.0-beta.19",
+    "@allurereport/plugin-dashboard": "3.0.0-beta.19",
+    "@allurereport/plugin-log": "3.0.0-beta.19",
+    "@allurereport/plugin-progress": "3.0.0-beta.19",
+    "@allurereport/plugin-server-reload": "3.0.0-beta.19",
+    "@allurereport/plugin-slack": "3.0.0-beta.19",
+    "@allurereport/reader-api": "3.0.0-beta.19",
+    "@allurereport/service": "3.0.0-beta.19",
+    "@allurereport/static-server": "3.0.0-beta.19",
+    "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",
@@ -61,7 +67,7 @@
     "@typescript-eslint/parser": "^8.0.0",
     "@vitest/runner": "^2.1.9",
     "@vitest/snapshot": "^2.1.9",
-    "allure-vitest": "^3.3.0",
+    "allure-vitest": "^3.3.3",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.29.1",