allure 3.15.0 → 3.16.1

package/dist/commands/dashboard.js

@@ -5,15 +5,15 @@ import { AllureReport, readConfig } from "@allurereport/core";
 import DashboardPlugin from "@allurereport/plugin-dashboard";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
-import { findAllureResultDirectories } from "../utils/fileSystem.js";
+import { resolveAndFindResultsDirs } from "../utils/resultsPatterns.js";
 export class DashboardCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Patterns to match test results directories. Overrides config.resultsDir. Defaults to ./**/allure-results when neither is set.",
         });
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.cwd = Option.String("--cwd", {
             description: "The working directory for the command to run (default: current working directory)",
@@ -39,12 +39,6 @@ export class DashboardCommand extends Command {
     }
     async execute() {
         const cwd = await realpath(this.cwd ?? process.cwd());
-        const { resultDirectories, patterns } = await findAllureResultDirectories(cwd, this.resultsDir);
-        if (!resultDirectories.length) {
-            console.error(red(`No test results directories found matching pattern: ${patterns}`));
-            exit(1);
-            return;
-        }
         const before = new Date().getTime();
         const defaultDashboardOptions = {
             singleFile: this.singleFile ?? false,
@@ -56,6 +50,12 @@ export class DashboardCommand extends Command {
             output: this.output,
             name: this.reportName,
         });
+        const { resultDirectories, patterns } = await resolveAndFindResultsDirs(cwd, this.resultsDir, config.resultsDir);
+        if (!resultDirectories.length) {
+            console.error(red(`No test results directories found matching pattern: ${patterns}`));
+            exit(1);
+            return;
+        }
         config.plugins = [
             {
                 id: "dashboard",

package/dist/commands/generate.js

@@ -7,10 +7,10 @@ export class GenerateCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Patterns to match test results directories. Overrides config.resultsDir. Defaults to ./**/allure-results when neither is set.",
         });
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.output = Option.String("--output,-o", {
             description: "The output directory name. Absolute paths are accepted as well (default: allure-report)",
@@ -39,7 +39,8 @@ export class GenerateCommand extends Command {
             description: "Hide labels by exact name in generated reports. Repeat the option for multiple labels",
         });
         this.knownIssues = Option.String("--known-issues", {
-            description: "Path to known issues file",
+            description: "Path to known issues file. " +
+                "Allure loads the file and updates it every time with the actual resolutions data of type `issue`",
         });
     }
     async execute() {
@@ -52,7 +53,7 @@ export class GenerateCommand extends Command {
             port: this.port,
             hideLabels,
             historyLimit: this.historyLimit !== undefined ? parseInt(this.historyLimit, 10) : undefined,
-            knownIssuesPath: this.knownIssues,
+            resolutions: { knownIssuesPath: this.knownIssues },
         });
         await generate({
             dump: this.dump,

package/dist/commands/history.js

@@ -1,14 +1,14 @@
 import * as console from "node:console";
 import process, { exit } from "node:process";
-import { AllureReport, resolveConfig } from "@allurereport/core";
+import { AllureReport, readRawConfig, resolveConfig } from "@allurereport/core";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
-import { findAllureResultDirectories } from "../utils/fileSystem.js";
+import { resolveAndFindResultsDirs } from "../utils/resultsPatterns.js";
 export class HistoryCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Patterns to match test results directories. Overrides config.resultsDir. Defaults to ./**/allure-results when neither is set.",
         });
         this.historyPath = Option.String("--history-path,-h", {
             description: "The path to history file",
@@ -21,7 +21,9 @@ export class HistoryCommand extends Command {
         });
     }
     async execute() {
-        const { resultDirectories, patterns } = await findAllureResultDirectories(process.cwd(), this.resultsDir);
+        const cwd = process.cwd();
+        const rawConfig = await readRawConfig(cwd);
+        const { resultDirectories, patterns } = await resolveAndFindResultsDirs(cwd, this.resultsDir, rawConfig.resultsDir);
         if (!resultDirectories.length) {
             console.error(red(`No test results directories found matching pattern: ${patterns}`));
             exit(1);

package/dist/commands/index.d.ts

@@ -10,6 +10,7 @@ export * from "./history.js";
 export * from "./run.js";
 export * from "./slack.js";
 export * from "./testplan.js";
+export * from "./testopsPlan.js";
 export * from "./watch.js";
 export * from "./open.js";
 export * from "./qualityGate.js";

package/dist/commands/index.js

@@ -10,6 +10,7 @@ export * from "./history.js";
 export * from "./run.js";
 export * from "./slack.js";
 export * from "./testplan.js";
+export * from "./testopsPlan.js";
 export * from "./watch.js";
 export * from "./open.js";
 export * from "./qualityGate.js";

package/dist/commands/jira/clear.js

@@ -8,7 +8,7 @@ class BaseJiraCommand extends Command {
     constructor() {
         super(...arguments);
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.cwd = Option.String("--cwd", {
             description: "The working directory for the command to run (default: current working directory)",

package/dist/commands/log.js

@@ -5,15 +5,15 @@ import { AllureReport, readConfig } from "@allurereport/core";
 import LogPlugin from "@allurereport/plugin-log";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
-import { findAllureResultDirectories } from "../utils/fileSystem.js";
+import { resolveAndFindResultsDirs } from "../utils/resultsPatterns.js";
 export class LogCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Patterns to match test results directories. Overrides config.resultsDir. Defaults to ./**/allure-results when neither is set.",
         });
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.cwd = Option.String("--cwd", {
             description: "The working directory for the command to run (default: current working directory)",
@@ -30,12 +30,6 @@ export class LogCommand extends Command {
     }
     async execute() {
         const cwd = await realpath(this.cwd ?? process.cwd());
-        const { resultDirectories, patterns } = await findAllureResultDirectories(cwd, this.resultsDir);
-        if (!resultDirectories.length) {
-            console.error(red(`No test results directories found matching pattern: ${patterns}`));
-            exit(1);
-            return;
-        }
         const before = new Date().getTime();
         const defaultLogOptions = {
             allSteps: this.allSteps ?? false,
@@ -43,6 +37,12 @@ export class LogCommand extends Command {
             groupBy: this.groupBy ?? "suite",
         };
         const config = await readConfig(cwd, this.config);
+        const { resultDirectories, patterns } = await resolveAndFindResultsDirs(cwd, this.resultsDir, config.resultsDir);
+        if (!resultDirectories.length) {
+            console.error(red(`No test results directories found matching pattern: ${patterns}`));
+            exit(1);
+            return;
+        }
         config.plugins = [
             {
                 id: "log",

package/dist/commands/open.js

@@ -8,15 +8,17 @@ import { serve } from "@allurereport/static-server";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
 import { findFilesByGlobs } from "./../utils/fileSystem.js";
+import { resolveResultsPatterns } from "./../utils/resultsPatterns.js";
+import { notifySignals, waitForAbort } from "./../utils/signals.js";
 import { generate } from "./commons/generate.js";
 export class OpenCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "A report to open or a pattern to match test results directories in the current working directory (default: configured output)",
+            name: "A report path to open, or results patterns. Overrides config.resultsDir. Empty Rest serves the configured output.",
         });
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.port = Option.String("--port", {
             description: "The port to serve the reports on. If not set, the server starts on a random port",
@@ -35,6 +37,7 @@ export class OpenCommand extends Command {
             port: this.port,
         });
         const servePath = this.resolveReportPath(cwd, this.resultsDir, config.output);
+        const resolvedPatterns = resolveResultsPatterns(this.resultsDir, config.resultsDir);
         if (await this.reportExists(servePath)) {
             await serve({
                 port: config.port ? parseInt(config.port, 10) : undefined,
@@ -42,7 +45,7 @@ export class OpenCommand extends Command {
                 open: true,
             });
         }
-        else if (this.resultsDir.length) {
+        else if (resolvedPatterns.length) {
             const tmpDir = await mkdtemp(join(tmpdir(), "allure-report-"));
             const config = await readConfig(cwd, this.config, {
                 port: this.port,
@@ -54,12 +57,13 @@ export class OpenCommand extends Command {
                 cwd,
                 config,
             });
-            process.on("SIGINT", async () => {
+            const notifier = notifySignals(["SIGINT", "SIGTERM"]);
+            void waitForAbort(notifier.signal).then(async () => {
                 try {
                     await rm(config.output, { recursive: true });
                 }
                 catch { }
-                process.exit(0);
+                process.exit(notifier.info()?.code ?? 0);
             });
             await serve({
                 port: config.port ? parseInt(config.port, 10) : undefined,

package/dist/commands/qualityGate.js

@@ -6,15 +6,15 @@ import { Command, Option } from "clipanion";
 import * as typanion from "typanion";
 import { red } from "yoctocolors";
 import { environmentNameOption, environmentOption, normalizeCommandEnvironmentOptions, resolveCommandEnvironment, } from "../utils/environment.js";
-import { findAllureResultDirectories } from "../utils/fileSystem.js";
+import { resolveAndFindResultsDirs } from "../utils/resultsPatterns.js";
 export class QualityGateCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Patterns to match test results directories. Overrides config.resultsDir. Defaults to ./**/allure-results when neither is set.",
         });
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.fastFail = Option.Boolean("--fast-fail", {
             description: "Force the command to fail if there are any rule failures",
@@ -49,7 +49,7 @@ export class QualityGateCommand extends Command {
         const cwd = await realpath(this.cwd ?? processCwd());
         const { maxFailures, minTestsCount, successRate, fastFail } = this;
         const config = await readConfig(cwd, this.config, {
-            knownIssuesPath: this.knownIssues,
+            resolutions: { knownIssuesPath: this.knownIssues },
         });
         const resolvedEnvironment = resolveCommandEnvironment(config, environmentOptions);
         const rules = {};
@@ -81,13 +81,12 @@ export class QualityGateCommand extends Command {
             exit(-1);
             return;
         }
-        const { resultDirectories, patterns } = await findAllureResultDirectories(cwd, this.resultsDir);
+        const { resultDirectories, patterns } = await resolveAndFindResultsDirs(cwd, this.resultsDir, config.resultsDir);
         if (!resultDirectories.length) {
             console.error(red(`No test results directories found matching pattern: ${patterns}`));
             exit(1);
             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)));
@@ -95,7 +94,6 @@ export class QualityGateCommand extends Command {
             const { results, fastFailed } = await allureReport.validate({
                 trs: nonRetryTrs,
                 environment: resolvedEnvironment?.id,
-                knownIssues,
                 state,
             });
             if (!fastFailed) {
@@ -112,7 +110,6 @@ export class QualityGateCommand extends Command {
         const allTrs = await allureReport.store.allTestResults({ includeRetries: false });
         const validationResults = await allureReport.validate({
             trs: allTrs,
-            knownIssues,
             environment: resolvedEnvironment?.id,
         });
         if (validationResults.results.length === 0) {

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

@@ -5,6 +5,7 @@ export declare class ResultsPackCommand extends Command {
     static usage: import("clipanion").Usage;
     resultsDir: string | undefined;
     name: string | undefined;
+    config: string | undefined;
     cwd: string | undefined;
     execute(): Promise<void>;
 }

package/dist/commands/results/pack.js

@@ -9,44 +9,42 @@ import * as fs from "node:fs/promises";
 import { realpath } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
 import { exit } from "node:process";
+import { readRawConfig } from "@allurereport/core";
 import AdmZip from "adm-zip";
 import { Command, Option } from "clipanion";
-import { glob } from "glob";
 import { green, red } from "yoctocolors";
+import { resolveAndFindResultsDirs } from "../../utils/resultsPatterns.js";
 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)",
+            name: "Pattern to match test results directories. Overrides config.resultsDir. Defaults to ./**/allure-results when neither is set.",
         });
         this.name = Option.String("--name", {
             description: "The archive name (default: allure-results.zip)",
         });
+        this.config = Option.String("--config,-c", {
+            description: "The path to Allure config file",
+        });
         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 rawConfig = await readRawConfig(cwd, this.config);
+        const cliPatterns = this.resultsDir ? [this.resultsDir] : [];
+        const { resultDirectories, patterns } = await resolveAndFindResultsDirs(cwd, cliPatterns, rawConfig.resultsDir);
         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) => /(\/|\\)$/.test(p));
         const resultsFiles = new Set();
-        if (resultsDirectories.length === 0) {
-            console.error(red(`No test results directories found matching pattern: ${resultsDir}`));
+        if (resultDirectories.length === 0) {
+            console.error(red(`No test results directories found matching pattern: ${patterns}`));
             exit(1);
             return;
         }
-        for (const dir of resultsDirectories) {
+        for (const dir of resultDirectories) {
             const files = await fs.readdir(dir);
             if (files.length === 0) {
                 continue;

package/dist/commands/run.d.ts

@@ -17,6 +17,7 @@ export declare class RunCommand extends Command {
     historyLimit: string | undefined;
     hideLabels: string[] | undefined;
     knownIssues: string | undefined;
+    resultsDir: string[] | undefined;
     commandToRun: string[];
     get logs(): "pipe" | "inherit" | "ignore";
     execute(): Promise<void>;

package/dist/commands/run.js

@@ -7,12 +7,14 @@ import { serve } from "@allurereport/static-server";
 import { Command, Option, UsageError } from "clipanion";
 import { environmentNameOption, environmentOption, normalizeCommandEnvironmentOptions, resolveCommandEnvironment, } from "../utils/environment.js";
 import { createChildAllureCliEnvironment, getActiveAllureCliCommand } from "../utils/execution-context.js";
+import { parseRunCommand, resolveResultsPatterns } from "../utils/resultsPatterns.js";
 import { executeAllureRun, executeNestedAllureCommand } from "./commons/run.js";
+const missingRunCommandUsageError = () => new UsageError("expecting command to be specified after --, e.g. allure run -- npm run test");
 export class RunCommand extends Command {
     constructor() {
         super(...arguments);
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.cwd = Option.String("--cwd", {
             description: "The working directory for the command to run (default: current working directory)",
@@ -52,6 +54,9 @@ export class RunCommand extends Command {
         this.knownIssues = Option.String("--known-issues", {
             description: "Path to known issues file",
         });
+        this.resultsDir = Option.Array("--results-dir", {
+            description: "Glob pattern or path for Allure results directories (repeatable). Overrides config.resultsDir. Quote globs in the shell",
+        });
         this.commandToRun = Option.Rest();
     }
     get logs() {
@@ -61,17 +66,15 @@ export class RunCommand extends Command {
         return this.ignoreLogs ? "inherit" : "pipe";
     }
     async execute() {
-        const args = this.commandToRun.filter((arg) => arg !== "--");
-        if (!args || !args.length) {
-            throw new UsageError("expecting command to be specified after --, e.g. allure run -- npm run test");
+        const { command, commandArgs } = parseRunCommand(this.commandToRun);
+        if (!command) {
+            throw missingRunCommandUsageError();
         }
         const before = new Date().getTime();
         process.on("exit", (exitCode) => {
             const after = new Date().getTime();
             console.log(`exit code ${exitCode} (${after - before}ms)`);
         });
-        const command = args[0];
-        const commandArgs = args.slice(1);
         const cwd = await realpath(this.cwd ?? process.cwd());
         const hideLabels = this.hideLabels?.length ? this.hideLabels : undefined;
         console.log(`${command} ${commandArgs.join(" ")}`);
@@ -98,8 +101,9 @@ export class RunCommand extends Command {
             port: this.port,
             hideLabels,
             historyLimit: this.historyLimit !== undefined ? parseInt(this.historyLimit, 10) : undefined,
-            knownIssuesPath: this.knownIssues,
+            resolutions: { knownIssuesPath: this.knownIssues },
         });
+        const resultsPatterns = resolveResultsPatterns(this.resultsDir ?? [], config.resultsDir);
         const resolvedEnvironment = resolveCommandEnvironment(config, environmentOptions);
         const withRerun = maxRerun > 0;
         const withQualityGate = !!config.qualityGate && !withRerun;
@@ -135,10 +139,8 @@ export class RunCommand extends Command {
                     ]),
             ],
         });
-        const knownIssues = await allureReport.store.allKnownIssues();
         const { globalExitCode } = await executeAllureRun({
             allureReport,
-            knownIssues,
             cwd,
             command,
             commandArgs,
@@ -149,6 +151,7 @@ export class RunCommand extends Command {
             silent: this.silent,
             ignoreLogs: this.ignoreLogs,
             maxRerun,
+            resultsPatterns,
         });
         if (config.open) {
             await serve({
@@ -165,7 +168,10 @@ export class RunCommand extends Command {
 RunCommand.paths = [["run"]];
 RunCommand.usage = Command.Usage({
     description: "Run specified command",
-    details: "This command runs the specified command and collects Allure results.",
+    details: "This command runs the specified command and collects Allure results. " +
+        "Override results discovery with repeated `--results-dir` (CLI overrides `config.resultsDir`). " +
+        "When neither is set, directories named `allure-results` are discovered dynamically. " +
+        "Quote globs in the shell so they are not expanded early.",
     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"],
@@ -173,5 +179,9 @@ RunCommand.usage = Command.Usage({
             "run --dump=my-dump -- npm run test",
             "Run npm run test and pack inner report state into my-dump.zip archive to restore the state in the next run",
         ],
+        [
+            "run --results-dir './artifacts/**/allure-results' -- npm test",
+            "Override results discovery with a quoted glob",
+        ],
     ],
 });

package/dist/commands/slack.js

@@ -5,15 +5,15 @@ import { AllureReport, readConfig } from "@allurereport/core";
 import SlackPlugin from "@allurereport/plugin-slack";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
-import { findAllureResultDirectories } from "../utils/fileSystem.js";
+import { resolveAndFindResultsDirs } from "../utils/resultsPatterns.js";
 export class SlackCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Patterns to match test results directories. Overrides config.resultsDir. Defaults to ./**/allure-results when neither is set.",
         });
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.cwd = Option.String("--cwd", {
             description: "The working directory for the command to run (default: current working directory)",
@@ -29,18 +29,18 @@ export class SlackCommand extends Command {
     }
     async execute() {
         const cwd = await realpath(this.cwd ?? process.cwd());
-        const { resultDirectories, patterns } = await findAllureResultDirectories(cwd, this.resultsDir);
-        if (!resultDirectories.length) {
-            console.error(red(`No test results directories found matching pattern: ${patterns}`));
-            exit(1);
-            return;
-        }
         const before = new Date().getTime();
         const defaultSlackOptions = {
             token: this.token,
             channel: this.channel,
         };
         const config = await readConfig(cwd, this.config);
+        const { resultDirectories, patterns } = await resolveAndFindResultsDirs(cwd, this.resultsDir, config.resultsDir);
+        if (!resultDirectories.length) {
+            console.error(red(`No test results directories found matching pattern: ${patterns}`));
+            exit(1);
+            return;
+        }
         config.plugins = [
             {
                 id: "slack",

package/dist/commands/testopsPlan.d.ts

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

package/dist/commands/testopsPlan.js

@@ -0,0 +1,65 @@
+import * as console from "node:console";
+import { rm, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { env, exit } from "node:process";
+import { applyAllureCiEnv } from "@allurereport/ci";
+import { createServiceHttpClient } from "@allurereport/service";
+import { Command, Option } from "clipanion";
+import { red } from "yoctocolors";
+export class TestOpsPlanCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.output = Option.String("--output,-o", {
+            description: "The output file name. Absolute paths are accepted as well (default: ./testplan.json)",
+        });
+    }
+    async execute() {
+        applyAllureCiEnv();
+        const jobRunId = Number(env.ALLURE_JOB_RUN_ID);
+        if (!Number.isInteger(jobRunId) || jobRunId <= 0) {
+            console.log("ALLURE_JOB_RUN_ID isn't set, skipping test plan generation");
+            return;
+        }
+        const endpoint = env.ALLURE_ENDPOINT;
+        const accessToken = env.ALLURE_TOKEN;
+        if (!endpoint || !accessToken) {
+            console.error(red("ALLURE_ENDPOINT and ALLURE_TOKEN are required to fetch a test plan from TestOps"));
+            exit(1);
+            return;
+        }
+        const client = createServiceHttpClient(endpoint, { apiToken: accessToken });
+        const output = resolve(this.output ?? "./testplan.json");
+        let tests;
+        try {
+            tests = await client.get(`/api/rs/jobrun/${jobRunId}/plan`, {
+                params: { expected: "true" },
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await rm(output, { force: true });
+            console.error(red(`Could not fetch the test plan for job run ${jobRunId}, continuing without one: ${message}`));
+            return;
+        }
+        const testPlan = {
+            version: "1.0",
+            tests: (tests ?? []).map(({ id, selector }) => ({
+                ...(id !== undefined ? { id: String(id) } : {}),
+                ...(selector !== undefined ? { selector } : {}),
+            })),
+        };
+        await writeFile(output, JSON.stringify(testPlan), "utf-8");
+        console.log(`test plan for job run ${jobRunId} written to ${output} (${testPlan.tests.length} test(s))`);
+    }
+}
+TestOpsPlanCommand.paths = [["testops-plan"]];
+TestOpsPlanCommand.usage = Command.Usage({
+    description: "Fetches a testplan.json for the current TestOps job run",
+    details: "Reads ALLURE_JOB_RUN_ID and, when it's set, downloads the test cases selected for that job run " +
+        "from TestOps and writes them as a testplan.json compatible with ALLURE_TESTPLAN_PATH. " +
+        "Does nothing when ALLURE_JOB_RUN_ID isn't set, which covers every run TestOps didn't trigger itself.",
+    examples: [
+        ["testops-plan", "Write ./testplan.json from the current job run, if any"],
+        ["testops-plan --output custom-testplan.json", "Write to a custom path instead"],
+    ],
+});

package/dist/commands/testplan.js

@@ -1,22 +1,24 @@
 import * as console from "node:console";
 import { basename, dirname, resolve } from "node:path";
-import { exit } from "node:process";
-import { AllureReport, resolveConfig } from "@allurereport/core";
+import { cwd as processCwd, exit } from "node:process";
+import { AllureReport, readRawConfig, resolveConfig } from "@allurereport/core";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
-import { findAllureResultDirectories } from "../utils/fileSystem.js";
+import { resolveAndFindResultsDirs } from "../utils/resultsPatterns.js";
 export class TestPlanCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Patterns to match test results directories. Overrides config.resultsDir. Defaults to ./**/allure-results when neither is set.",
         });
         this.output = Option.String("--output,-o", {
             description: "The output file name. Absolute paths are accepted as well",
         });
     }
     async execute() {
-        const { resultDirectories, patterns } = await findAllureResultDirectories(process.cwd(), this.resultsDir);
+        const cwd = processCwd();
+        const rawConfig = await readRawConfig(cwd);
+        const { resultDirectories, patterns } = await resolveAndFindResultsDirs(cwd, this.resultsDir, rawConfig.resultsDir);
         if (!resultDirectories.length) {
             console.error(red(`No test results directories found matching pattern: ${patterns}`));
             exit(1);

package/dist/commands/watch.d.ts

@@ -10,5 +10,6 @@ export declare class WatchCommand extends Command {
     open: boolean | undefined;
     port: string | undefined;
     preserve: boolean | undefined;
+    newOnly: boolean;
     execute(): Promise<void>;
 }