@allurereport/core 3.0.1 → 3.2.0

package/dist/history.d.ts

@@ -1,7 +1,7 @@
 import type { AllureHistory, HistoryDataPoint, TestCase, TestResult } from "@allurereport/core-api";
 export declare const createHistory: (reportUuid: string, reportName: string | undefined, testCases: TestCase[], testResults: TestResult[], remoteUrl?: string) => HistoryDataPoint;
-export declare const writeHistory: (historyPath: string, data: HistoryDataPoint) => Promise<void>;
 export declare class AllureLocalHistory implements AllureHistory {
+    #private;
     private readonly params;
     constructor(params: {
         historyPath: string;

package/dist/history.js

@@ -1,5 +1,14 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
+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 _AllureLocalHistory_openFileToReadIfExists, _AllureLocalHistory_ensureFileOpenedToAppend, _AllureLocalHistory_findFirstEntryAddress, _AllureLocalHistory_throwUnexpectedReadError;
+import { once } from "node:events";
+import { mkdir, open } from "node:fs/promises";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { pipeline } from "node:stream/promises";
 import { isFileNotFoundError } from "./utils/misc.js";
 const createHistoryItems = (testResults) => {
     return testResults
@@ -39,46 +48,127 @@ export const createHistory = (reportUuid, reportName = "Allure Report", testCase
         url: remoteUrl,
     };
 };
-export const writeHistory = async (historyPath, data) => {
-    const path = resolve(historyPath);
-    const parentDir = dirname(path);
-    await mkdir(parentDir, { recursive: true });
-    await writeFile(path, `${JSON.stringify(data)}\n`, { encoding: "utf-8", flag: "a+" });
-};
 export class AllureLocalHistory {
     constructor(params) {
         this.params = params;
+        _AllureLocalHistory_openFileToReadIfExists.set(this, async (filePath) => {
+            try {
+                return await open(filePath, "r");
+            }
+            catch (e) {
+                if (isFileNotFoundError(e)) {
+                    return undefined;
+                }
+                throw e;
+            }
+        });
+        _AllureLocalHistory_ensureFileOpenedToAppend.set(this, async (filePath) => {
+            try {
+                return {
+                    file: await open(filePath, "r+"),
+                    exists: true,
+                };
+            }
+            catch (e) {
+                if (isFileNotFoundError(e)) {
+                    return {
+                        file: await open(filePath, "w"),
+                        exists: false,
+                    };
+                }
+                throw e;
+            }
+        });
+        _AllureLocalHistory_findFirstEntryAddress.set(this, async (jsonlFile, limit) => {
+            if (limit === undefined) {
+                return 0;
+            }
+            if (limit < 0) {
+                throw new Error(`Invalid history limit ${limit}. A history limit must be a positive integer number`);
+            }
+            const stat = await jsonlFile.stat();
+            let { size: position } = stat;
+            const { mtimeMs: originalMtime } = stat;
+            if (position === 0 || limit === 0) {
+                return position;
+            }
+            const buffer = Buffer.alloc(Buffer.poolSize);
+            while (position) {
+                const bytesToRead = Math.min(position, buffer.byteLength);
+                position -= bytesToRead;
+                const { bytesRead } = await jsonlFile.read({ buffer, length: bytesToRead, position });
+                if (bytesRead !== bytesToRead) {
+                    __classPrivateFieldGet(this, _AllureLocalHistory_throwUnexpectedReadError, "f").call(this, jsonlFile, originalMtime, bytesToRead, bytesRead);
+                }
+                for (let i = bytesToRead - 1; i >= 0; i--) {
+                    if (buffer[i] === 0x0a) {
+                        if (limit-- === 0) {
+                            return position + i + 1;
+                        }
+                    }
+                }
+            }
+            return 0;
+        });
+        _AllureLocalHistory_throwUnexpectedReadError.set(this, async (file, mtime, expectedBytes, actualBytes) => {
+            const { mtimeMs: currentMtime } = await file.stat();
+            if (currentMtime !== mtime) {
+                throw new Error("The history file was modified outside Allure. " +
+                    "Please, make sure the file doesn't change while Allure is running");
+            }
+            throw new Error(`Can't read the history file: the expected number of bytes to read ${expectedBytes} ` +
+                `doesn't match the actual number ${actualBytes}`);
+        });
     }
     async readHistory() {
-        const path = resolve(this.params.historyPath);
+        const fullPath = path.resolve(this.params.historyPath);
+        const historyFile = await __classPrivateFieldGet(this, _AllureLocalHistory_openFileToReadIfExists, "f").call(this, fullPath);
+        if (historyFile === undefined) {
+            return [];
+        }
         try {
-            const historyPoints = (await readFile(path, { encoding: "utf-8" }))
-                .split("\n")
-                .filter((line) => line && line.trim() !== "")
-                .map((line) => JSON.parse(line));
-            if (this.params.limit) {
-                return historyPoints.slice(-this.params.limit);
-            }
+            const start = await __classPrivateFieldGet(this, _AllureLocalHistory_findFirstEntryAddress, "f").call(this, historyFile, this.params.limit);
+            const stream = historyFile.createReadStream({ start, encoding: "utf-8", autoClose: false });
+            const historyPoints = [];
+            const readlineInterface = readline
+                .createInterface({ input: stream, terminal: false, crlfDelay: Infinity })
+                .on("line", (line) => {
+                if (line && line.trim().length) {
+                    const historyEntry = JSON.parse(line);
+                    historyPoints.push(historyEntry);
+                }
+            });
+            await once(readlineInterface, "close");
             return historyPoints;
         }
-        catch (e) {
-            if (isFileNotFoundError(e)) {
-                return [];
-            }
-            throw e;
+        finally {
+            await historyFile.close();
         }
     }
     async appendHistory(data) {
-        const path = resolve(this.params.historyPath);
-        const parentDir = dirname(path);
+        const fullPath = path.resolve(this.params.historyPath);
+        const parentDir = path.dirname(fullPath);
+        const { limit } = this.params;
         await mkdir(parentDir, { recursive: true });
-        if (!this.params.limit) {
-            await writeFile(path, `${JSON.stringify(data)}\n`, { encoding: "utf-8", flag: "a+" });
-            return;
+        const { file: historyFile, exists: historyExists } = await __classPrivateFieldGet(this, _AllureLocalHistory_ensureFileOpenedToAppend, "f").call(this, fullPath);
+        try {
+            const dst = historyFile.createWriteStream({ encoding: "utf-8", start: 0, autoClose: false });
+            if (limit !== 0) {
+                if (historyExists) {
+                    const start = limit ? await __classPrivateFieldGet(this, _AllureLocalHistory_findFirstEntryAddress, "f").call(this, historyFile, limit - 1) : 0;
+                    const src = historyFile.createReadStream({ start, autoClose: false });
+                    await pipeline(src, dst, { end: false });
+                }
+                const sources = [JSON.stringify(data), Buffer.from([0x0a])];
+                await pipeline(sources, dst);
+            }
+            if (historyExists) {
+                await historyFile.truncate(dst.bytesWritten);
+            }
+        }
+        finally {
+            await historyFile.close();
         }
-        const existingHistory = await this.readHistory();
-        const updatedHistory = [...existingHistory, data].slice(-this.params.limit);
-        const fileContent = updatedHistory.reduce((acc, point) => `${acc}${JSON.stringify(point)}\n`, "");
-        await writeFile(path, fileContent, "utf-8");
     }
 }
+_AllureLocalHistory_openFileToReadIfExists = new WeakMap(), _AllureLocalHistory_ensureFileOpenedToAppend = new WeakMap(), _AllureLocalHistory_findFirstEntryAddress = new WeakMap(), _AllureLocalHistory_throwUnexpectedReadError = new WeakMap();

package/dist/qualityGate/qualityGate.d.ts

@@ -1,4 +1,4 @@
-import type { KnownTestFailure, TestError, TestResult } from "@allurereport/core-api";
+import { type KnownTestFailure, type TestError, type TestResult } from "@allurereport/core-api";
 import type { QualityGateConfig, QualityGateValidationResult } from "@allurereport/plugin-api";
 export declare const stringifyQualityGateResults: (results: QualityGateValidationResult[]) => string;
 export declare const convertQualityGateResultsToTestErrors: (results: QualityGateValidationResult[]) => TestError[];
@@ -14,6 +14,7 @@ export declare class QualityGate {
         state?: QualityGateState;
         trs: TestResult[];
         knownIssues: KnownTestFailure[];
+        environment?: string;
     }): Promise<{
         fastFailed: boolean;
         results: QualityGateValidationResult[];

package/dist/qualityGate/qualityGate.js

@@ -4,6 +4,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _QualityGateState_state;
+import { DEFAULT_ENVIRONMENT } from "@allurereport/core-api";
 import { gray, red } from "yoctocolors";
 import { qualityGateDefaultRules } from "./rules.js";
 export const stringifyQualityGateResults = (results) => {
@@ -44,7 +45,7 @@ export class QualityGate {
         this.config = config;
     }
     async validate(payload) {
-        const { state, trs, knownIssues } = payload;
+        const { state, trs, knownIssues, environment } = payload;
         const { rules, use = [...qualityGateDefaultRules] } = this.config;
         const results = [];
         let fastFailed = false;
@@ -88,6 +89,7 @@ export class QualityGate {
                         actual: result.actual,
                         expected,
                     }),
+                    environment: environment || DEFAULT_ENVIRONMENT,
                 });
                 if (ruleset.fastFail) {
                     fastFailed = true;

package/dist/report.d.ts

@@ -20,6 +20,7 @@ export declare class AllureReport {
         trs: TestResult[];
         knownIssues: KnownTestFailure[];
         state?: QualityGateState;
+        environment?: string;
     }) => Promise<{
         fastFailed: boolean;
         results: import("@allurereport/plugin-api").QualityGateValidationResult[];

package/dist/report.js

@@ -95,15 +95,16 @@ export class AllureReport {
                         return;
                     }
                 }
-                catch (ignored) { }
+                catch { }
             }
         };
         this.validate = async (params) => {
-            const { trs, knownIssues, state } = params;
+            const { trs, knownIssues, state, environment } = params;
             return __classPrivateFieldGet(this, _AllureReport_qualityGate, "f").validate({
                 trs: trs.filter(Boolean),
                 knownIssues,
                 state,
+                environment,
             });
         };
         this.start = async () => {
@@ -143,7 +144,7 @@ export class AllureReport {
             });
         });
         this.dumpState = async () => {
-            const { testResults, testCases, fixtures, attachments: attachmentsLinks, environments, globalAttachments = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexLatestEnvTestResultByHistoryId = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, qualityGateResultsByRules = {}, } = __classPrivateFieldGet(this, _AllureReport_store, "f").dumpState();
+            const { testResults, testCases, fixtures, attachments: attachmentsLinks, environments, globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexLatestEnvTestResultByHistoryId = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, qualityGateResults = [], } = __classPrivateFieldGet(this, _AllureReport_store, "f").dumpState();
             const allAttachments = await __classPrivateFieldGet(this, _AllureReport_store, "f").allAttachments();
             const dumpArchive = new ZipWriteStream({
                 zlib: { level: 5 },
@@ -174,7 +175,7 @@ export class AllureReport {
             await addEntry(Buffer.from(JSON.stringify(__classPrivateFieldGet(this, _AllureReport_reportVariables, "f"))), {
                 name: AllureStoreDumpFiles.ReportVariables,
             });
-            await addEntry(Buffer.from(JSON.stringify(globalAttachments)), {
+            await addEntry(Buffer.from(JSON.stringify(globalAttachmentIds)), {
                 name: AllureStoreDumpFiles.GlobalAttachments,
             });
             await addEntry(Buffer.from(JSON.stringify(globalErrors)), {
@@ -201,8 +202,8 @@ export class AllureReport {
             await addEntry(Buffer.from(JSON.stringify(indexKnownByHistoryId)), {
                 name: AllureStoreDumpFiles.IndexKnownByHistoryId,
             });
-            await addEntry(Buffer.from(JSON.stringify(qualityGateResultsByRules)), {
-                name: AllureStoreDumpFiles.QualityGateResultsByRules,
+            await addEntry(Buffer.from(JSON.stringify(qualityGateResults)), {
+                name: AllureStoreDumpFiles.QualityGateResults,
             });
             for (const attachment of allAttachments) {
                 const content = await __classPrivateFieldGet(this, _AllureReport_store, "f").attachmentContentById(attachment.id);
@@ -246,7 +247,7 @@ export class AllureReport {
                 const indexAttachmentsByFixtureEntry = await dump.entryData(AllureStoreDumpFiles.IndexAttachmentsByFixture);
                 const indexFixturesByTestResultEntry = await dump.entryData(AllureStoreDumpFiles.IndexFixturesByTestResult);
                 const indexKnownByHistoryIdEntry = await dump.entryData(AllureStoreDumpFiles.IndexKnownByHistoryId);
-                const qualityGateResultsByRulesEntry = await dump.entryData(AllureStoreDumpFiles.QualityGateResultsByRules);
+                const qualityGateResultsEntry = await dump.entryData(AllureStoreDumpFiles.QualityGateResults);
                 const attachmentsEntries = Object.entries(await dump.entries()).reduce((acc, [entryName, entry]) => {
                     switch (entryName) {
                         case AllureStoreDumpFiles.Attachments:
@@ -264,7 +265,7 @@ export class AllureReport {
                         case AllureStoreDumpFiles.IndexAttachmentsByFixture:
                         case AllureStoreDumpFiles.IndexFixturesByTestResult:
                         case AllureStoreDumpFiles.IndexKnownByHistoryId:
-                        case AllureStoreDumpFiles.QualityGateResultsByRules:
+                        case AllureStoreDumpFiles.QualityGateResults:
                             return acc;
                         default:
                             return Object.assign(acc, {
@@ -279,7 +280,7 @@ export class AllureReport {
                     attachments: JSON.parse(attachmentsEntry.toString("utf8")),
                     environments: JSON.parse(environmentsEntry.toString("utf8")),
                     reportVariables: JSON.parse(reportVariablesEntry.toString("utf8")),
-                    globalAttachments: JSON.parse(globalAttachmentsEntry.toString("utf8")),
+                    globalAttachmentIds: JSON.parse(globalAttachmentsEntry.toString("utf8")),
                     globalErrors: JSON.parse(globalErrorsEntry.toString("utf8")),
                     indexAttachmentByTestResult: JSON.parse(indexAttachmentsEntry.toString("utf8")),
                     indexTestResultByHistoryId: JSON.parse(indexTestResultsByHistoryId.toString("utf8")),
@@ -288,7 +289,7 @@ export class AllureReport {
                     indexAttachmentByFixture: JSON.parse(indexAttachmentsByFixtureEntry.toString("utf8")),
                     indexFixturesByTestResult: JSON.parse(indexFixturesByTestResultEntry.toString("utf8")),
                     indexKnownByHistoryId: JSON.parse(indexKnownByHistoryIdEntry.toString("utf8")),
-                    qualityGateResultsByRules: JSON.parse(qualityGateResultsByRulesEntry.toString("utf8")),
+                    qualityGateResults: JSON.parse(qualityGateResultsEntry.toString("utf8")),
                 };
                 const stageTempDir = await mkdtemp(join(tmpdir(), basename(stage, ".zip")));
                 const resultsAttachments = {};
@@ -412,14 +413,15 @@ export class AllureReport {
             try {
                 outputDirFiles = await readdir(__classPrivateFieldGet(this, _AllureReport_output, "f"));
             }
-            catch (ignored) { }
+            catch { }
             if (outputDirFiles.length === 0) {
                 return;
             }
             const reportPath = join(__classPrivateFieldGet(this, _AllureReport_output, "f"), outputDirFiles[0]);
+            const reportStats = await lstat(reportPath);
             const outputEntriesStats = await Promise.all(outputDirFiles.map((file) => lstat(join(__classPrivateFieldGet(this, _AllureReport_output, "f"), file))));
             const outputDirectoryEntries = outputEntriesStats.filter((entry) => entry.isDirectory());
-            if (outputDirectoryEntries.length === 1) {
+            if (reportStats.isDirectory() && outputDirectoryEntries.length === 1) {
                 const reportContent = await readdir(reportPath);
                 for (const entry of reportContent) {
                     const currentFilePath = join(reportPath, entry);
@@ -432,7 +434,7 @@ export class AllureReport {
                 try {
                     await rm(dir, { recursive: true });
                 }
-                catch (ignored) { }
+                catch { }
             }
             if (__classPrivateFieldGet(this, _AllureReport_history, "f")) {
                 try {
@@ -459,7 +461,7 @@ export class AllureReport {
             if (!__classPrivateFieldGet(this, _AllureReport_qualityGate, "f")) {
                 return;
             }
-            const qualityGateResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").qualityGateResults();
+            const qualityGateResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").qualityGateResultsByEnv();
             await writeFile(join(__classPrivateFieldGet(this, _AllureReport_output, "f"), "quality-gate.json"), JSON.stringify(qualityGateResults));
         };
         _AllureReport_eachPlugin.set(this, async (initState, consumer) => {
@@ -495,6 +497,7 @@ export class AllureReport {
                     state: pluginState,
                     reportFiles: pluginFiles,
                     reportUrl: this.reportUrl,
+                    output: __classPrivateFieldGet(this, _AllureReport_output, "f"),
                     ci: __classPrivateFieldGet(this, _AllureReport_ci, "f"),
                 };
                 try {

package/dist/store/convert.js

@@ -1,7 +1,6 @@
 import { findByLabelName, notNull } from "@allurereport/core-api";
 import { md5 } from "@allurereport/plugin-api";
 import { extension, lookupContentType } from "@allurereport/reader-api";
-import MarkdownIt from "markdown-it";
 import { randomUUID } from "node:crypto";
 const defaultStatus = "unknown";
 export const __unknown = "#___unknown_value___#";
@@ -47,11 +46,11 @@ export const testResultRawToState = (stateData, raw, context) => {
         },
         ...processTimings(raw),
         description: raw.description,
-        descriptionHtml: raw.descriptionHtml ?? markdownToHtml(raw.description),
+        descriptionHtml: raw.descriptionHtml,
         precondition: raw.precondition,
-        preconditionHtml: raw.preconditionHtml ?? markdownToHtml(raw.precondition),
+        preconditionHtml: raw.preconditionHtml,
         expectedResult: raw.expectedResult,
-        expectedResultHtml: raw.expectedResultHtml ?? markdownToHtml(raw.expectedResult),
+        expectedResultHtml: raw.expectedResultHtml,
         flaky: raw.flaky ?? false,
         muted: raw.muted ?? false,
         known: raw.known ?? false,
@@ -235,7 +234,6 @@ const convertLink = (link) => ({
     url: link.url ?? __unknown,
     type: link.type,
 });
-const markdownToHtml = (value) => (value ? new MarkdownIt().render(value) : undefined);
 const calculateTestId = (raw) => {
     const maybeAllureId = raw.labels?.find((label) => label.name === "ALLURE_ID" || label.name === "AS_ID")?.value;
     if (maybeAllureId) {

package/dist/store/store.d.ts

@@ -1,6 +1,6 @@
-import { type AllureHistory, type AttachmentLink, type DefaultLabelsConfig, type EnvironmentsConfig, type HistoryDataPoint, type HistoryTestResult, type KnownTestFailure, type ReportVariables, type Statistic, type TestCase, type TestEnvGroup, type TestError, type TestFixtureResult, type TestResult } from "@allurereport/core-api";
+import { type AllureHistory, type AttachmentLink, type AttachmentLinkLinked, type DefaultLabelsConfig, type EnvironmentsConfig, type HistoryDataPoint, type HistoryTestResult, type KnownTestFailure, type ReportVariables, type Statistic, type TestCase, type TestEnvGroup, type TestError, type TestFixtureResult, type TestResult } from "@allurereport/core-api";
 import { type AllureStore, type AllureStoreDump, type ExitCode, type QualityGateValidationResult, type RealtimeEventsDispatcher, type RealtimeSubscriber, type ResultFile, type TestResultFilter } from "@allurereport/plugin-api";
-import type { RawFixtureResult, RawMetadata, RawTestResult, ReaderContext, ResultsVisitor } from "@allurereport/reader-api";
+import type { RawFixtureResult, RawGlobals, RawMetadata, RawTestResult, ReaderContext, ResultsVisitor } from "@allurereport/reader-api";
 export declare const mapToObject: <K extends string | number | symbol, T = any>(map: Map<K, T>) => Record<K, T>;
 export declare const updateMapWithRecord: <K extends string | number | symbol, T = any>(map: Map<K, T>, record: Record<K, T>) => Map<K, T>;
 export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
@@ -25,16 +25,19 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     readHistory(): Promise<HistoryDataPoint[]>;
     appendHistory(history: HistoryDataPoint): Promise<void>;
     qualityGateResults(): Promise<QualityGateValidationResult[]>;
+    qualityGateResultsByEnv(): Promise<Record<string, QualityGateValidationResult[]>>;
     globalExitCode(): Promise<ExitCode | undefined>;
     allGlobalErrors(): Promise<TestError[]>;
-    allGlobalAttachments(): Promise<AttachmentLink[]>;
+    allGlobalAttachments(): Promise<AttachmentLinkLinked[]>;
     visitTestResult(raw: RawTestResult, context: ReaderContext): Promise<void>;
     visitTestFixtureResult(result: RawFixtureResult, context: ReaderContext): Promise<void>;
-    visitAttachmentFile(resultFile: ResultFile, context: ReaderContext): Promise<void>;
+    visitAttachmentFile(resultFile: ResultFile): Promise<void>;
     visitMetadata(metadata: RawMetadata): Promise<void>;
+    visitGlobals(globals: RawGlobals): Promise<void>;
     allTestCases(): Promise<TestCase[]>;
     allTestResults(options?: {
         includeHidden?: boolean;
+        filter?: TestResultFilter;
     }): Promise<TestResult[]>;
     allAttachments(options?: {
         includeMissed?: boolean;
@@ -45,7 +48,7 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     allHistoryDataPoints(): Promise<HistoryDataPoint[]>;
     allHistoryDataPointsByEnvironment(environment: string): Promise<HistoryDataPoint[]>;
     allKnownIssues(): Promise<KnownTestFailure[]>;
-    allNewTestResults(): Promise<TestResult[]>;
+    allNewTestResults(filter?: TestResultFilter): Promise<TestResult[]>;
     testCaseById(tcId: string): Promise<TestCase | undefined>;
     testResultById(trId: string): Promise<TestResult | undefined>;
     attachmentById(attachmentId: string): Promise<AttachmentLink | undefined>;

package/dist/store/store.js

@@ -9,9 +9,10 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _DefaultAllureStore_instances, _DefaultAllureStore_testResults, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_known, _DefaultAllureStore_fixtures, _DefaultAllureStore_defaultLabels, _DefaultAllureStore_environment, _DefaultAllureStore_environmentsConfig, _DefaultAllureStore_reportVariables, _DefaultAllureStore_realtimeDispatcher, _DefaultAllureStore_realtimeSubscriber, _DefaultAllureStore_globalAttachments, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_qualityGateResultsByRules, _DefaultAllureStore_historyPoints, _DefaultAllureStore_environments, _DefaultAllureStore_addEnvironments;
+var _DefaultAllureStore_instances, _DefaultAllureStore_testResults, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_known, _DefaultAllureStore_fixtures, _DefaultAllureStore_defaultLabels, _DefaultAllureStore_environment, _DefaultAllureStore_environmentsConfig, _DefaultAllureStore_reportVariables, _DefaultAllureStore_realtimeDispatcher, _DefaultAllureStore_realtimeSubscriber, _DefaultAllureStore_globalAttachmentIds, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_qualityGateResults, _DefaultAllureStore_historyPoints, _DefaultAllureStore_environments, _DefaultAllureStore_addEnvironments;
 import { DEFAULT_ENVIRONMENT, compareBy, getWorstStatus, htrsByTr, matchEnvironment, nullsLast, ordinal, reverse, } from "@allurereport/core-api";
 import { md5, } from "@allurereport/plugin-api";
+import { extname } from "node:path";
 import { isFlaky } from "../utils/flaky.js";
 import { getStatusTransition } from "../utils/new.js";
 import { testFixtureResultRawToState, testResultRawToState } from "./convert.js";
@@ -86,10 +87,10 @@ export class DefaultAllureStore {
         this.indexAttachmentByFixture = new Map();
         this.indexFixturesByTestResult = new Map();
         this.indexKnownByHistoryId = new Map();
-        _DefaultAllureStore_globalAttachments.set(this, []);
+        _DefaultAllureStore_globalAttachmentIds.set(this, []);
         _DefaultAllureStore_globalErrors.set(this, []);
         _DefaultAllureStore_globalExitCode.set(this, void 0);
-        _DefaultAllureStore_qualityGateResultsByRules.set(this, {});
+        _DefaultAllureStore_qualityGateResults.set(this, []);
         _DefaultAllureStore_historyPoints.set(this, []);
         _DefaultAllureStore_environments.set(this, []);
         const { history, known = [], realtimeDispatcher, realtimeSubscriber, defaultLabels = {}, environment, environmentsConfig = {}, reportVariables = {}, } = params ?? {};
@@ -113,9 +114,7 @@ export class DefaultAllureStore {
         __classPrivateFieldSet(this, _DefaultAllureStore_reportVariables, reportVariables, "f");
         __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_addEnvironments).call(this, environments);
         __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onQualityGateResults(async (results) => {
-            results.forEach((result) => {
-                __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResultsByRules, "f")[result.rule] = result;
-            });
+            __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResults, "f").push(...results);
         });
         __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalExitCode(async (exitCode) => {
             __classPrivateFieldSet(this, _DefaultAllureStore_globalExitCode, exitCode, "f");
@@ -123,18 +122,21 @@ export class DefaultAllureStore {
         __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalError(async (error) => {
             __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f").push(error);
         });
-        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalAttachment(async (attachment) => {
+        __classPrivateFieldGet(this, _DefaultAllureStore_realtimeSubscriber, "f")?.onGlobalAttachment(async ({ attachment, fileName }) => {
+            const originalFileName = attachment.getOriginalFileName();
             const attachmentLink = {
-                id: md5(attachment.getOriginalFileName()),
+                id: md5(originalFileName),
+                name: fileName || originalFileName,
                 missed: false,
-                used: false,
+                used: true,
                 ext: attachment.getExtension(),
-                originalFileName: attachment.getOriginalFileName(),
                 contentType: attachment.getContentType(),
                 contentLength: attachment.getContentLength(),
+                originalFileName,
             };
+            __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").set(attachmentLink.id, attachmentLink);
             __classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f").set(attachmentLink.id, attachment);
-            __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachments, "f").push(attachmentLink);
+            __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachmentIds, "f").push(attachmentLink.id);
         });
     }
     async readHistory() {
@@ -153,7 +155,18 @@ export class DefaultAllureStore {
         await __classPrivateFieldGet(this, _DefaultAllureStore_history, "f").appendHistory(history);
     }
     async qualityGateResults() {
-        return Object.values(__classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResultsByRules, "f"));
+        return __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResults, "f");
+    }
+    async qualityGateResultsByEnv() {
+        const resultsByEnv = {};
+        for (const result of __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResults, "f")) {
+            const environment = result.environment || "default";
+            if (!resultsByEnv[environment]) {
+                resultsByEnv[environment] = [];
+            }
+            resultsByEnv[environment].push(result);
+        }
+        return resultsByEnv;
     }
     async globalExitCode() {
         return __classPrivateFieldGet(this, _DefaultAllureStore_globalExitCode, "f");
@@ -162,7 +175,14 @@ export class DefaultAllureStore {
         return __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f");
     }
     async allGlobalAttachments() {
-        return __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachments, "f");
+        return __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachmentIds, "f").reduce((acc, id) => {
+            const attachment = __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").get(id);
+            if (!attachment) {
+                return acc;
+            }
+            acc.push(attachment);
+            return acc;
+        }, []);
     }
     async visitTestResult(raw, context) {
         const attachmentLinks = [];
@@ -187,7 +207,7 @@ export class DefaultAllureStore {
         }
         testResult.environment = __classPrivateFieldGet(this, _DefaultAllureStore_environment, "f") || matchEnvironment(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f"), testResult);
         const trHistory = await this.historyByTr(testResult);
-        if (trHistory) {
+        if (trHistory !== undefined) {
             testResult.transition = getStatusTransition(testResult, trHistory);
             testResult.flaky = isFlaky(testResult, trHistory);
         }
@@ -211,7 +231,7 @@ export class DefaultAllureStore {
         index(this.indexAttachmentByFixture, testFixtureResult.id, ...attachmentLinks);
         __classPrivateFieldGet(this, _DefaultAllureStore_realtimeDispatcher, "f")?.sendTestFixtureResult(testFixtureResult.id);
     }
-    async visitAttachmentFile(resultFile, context) {
+    async visitAttachmentFile(resultFile) {
         const originalFileName = resultFile.getOriginalFileName();
         const id = md5(originalFileName);
         __classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f").set(id, resultFile);
@@ -237,18 +257,42 @@ export class DefaultAllureStore {
         __classPrivateFieldGet(this, _DefaultAllureStore_realtimeDispatcher, "f")?.sendAttachmentFile(id);
     }
     async visitMetadata(metadata) {
-        Object.keys(metadata).forEach((key) => __classPrivateFieldGet(this, _DefaultAllureStore_metadata, "f").set(key, metadata[key]));
+        Object.keys(metadata).forEach((key) => {
+            __classPrivateFieldGet(this, _DefaultAllureStore_metadata, "f").set(key, metadata[key]);
+        });
+    }
+    async visitGlobals(globals) {
+        const { errors, attachments } = globals;
+        __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f").push(...errors);
+        attachments.forEach((attachment) => {
+            const originalFileName = attachment.originalFileName;
+            const id = md5(originalFileName);
+            const attachmentLink = {
+                id,
+                name: attachment?.name || originalFileName,
+                originalFileName,
+                ext: extname(originalFileName),
+                used: true,
+                missed: false,
+                contentType: attachment?.contentType,
+            };
+            __classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f").set(id, attachmentLink);
+            __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachmentIds, "f").push(id);
+        });
     }
     async allTestCases() {
         return Array.from(__classPrivateFieldGet(this, _DefaultAllureStore_testCases, "f").values());
     }
     async allTestResults(options = { includeHidden: false }) {
-        const { includeHidden } = options;
+        const { includeHidden = false, filter } = options;
         const result = [];
         for (const [, tr] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {
             if (!includeHidden && tr.hidden) {
                 continue;
             }
+            if (typeof filter === "function" && !filter(tr)) {
+                continue;
+            }
             result.push(tr);
         }
         return result;
@@ -306,13 +350,19 @@ export class DefaultAllureStore {
     async allKnownIssues() {
         return __classPrivateFieldGet(this, _DefaultAllureStore_known, "f");
     }
-    async allNewTestResults() {
+    async allNewTestResults(filter) {
+        if (!__classPrivateFieldGet(this, _DefaultAllureStore_history, "f")) {
+            return [];
+        }
         const newTrs = [];
         const allHistoryDps = await this.allHistoryDataPoints();
         for (const [, tr] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {
             if (tr.hidden) {
                 continue;
             }
+            if (typeof filter === "function" && !filter(tr)) {
+                continue;
+            }
             if (!tr.historyId) {
                 newTrs.push(tr);
                 continue;
@@ -507,7 +557,7 @@ export class DefaultAllureStore {
             fixtures: mapToObject(__classPrivateFieldGet(this, _DefaultAllureStore_fixtures, "f")),
             environments: __classPrivateFieldGet(this, _DefaultAllureStore_environments, "f"),
             reportVariables: __classPrivateFieldGet(this, _DefaultAllureStore_reportVariables, "f"),
-            globalAttachments: __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachments, "f"),
+            globalAttachmentIds: __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachmentIds, "f"),
             globalErrors: __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f"),
             indexLatestEnvTestResultByHistoryId: {},
             indexAttachmentByTestResult: {},
@@ -516,7 +566,7 @@ export class DefaultAllureStore {
             indexAttachmentByFixture: {},
             indexFixturesByTestResult: {},
             indexKnownByHistoryId: {},
-            qualityGateResultsByRules: __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResultsByRules, "f"),
+            qualityGateResults: __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResults, "f"),
         };
         this.indexLatestEnvTestResultByHistoryId.forEach((envMap) => {
             envMap.forEach((tr, historyId) => {
@@ -544,14 +594,14 @@ export class DefaultAllureStore {
         return storeDump;
     }
     async restoreState(stateDump, attachmentsContents = {}) {
-        const { testResults, attachments, testCases, fixtures, reportVariables, environments, globalAttachments = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexLatestEnvTestResultByHistoryId = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, qualityGateResultsByRules = {}, } = stateDump;
+        const { testResults, attachments, testCases, fixtures, reportVariables, environments, globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexLatestEnvTestResultByHistoryId = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, indexKnownByHistoryId = {}, qualityGateResults = [], } = stateDump;
         updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f"), testResults);
         updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f"), attachments);
         updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_testCases, "f"), testCases);
         updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_fixtures, "f"), fixtures);
         updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_attachmentContents, "f"), attachmentsContents);
         __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_addEnvironments).call(this, environments);
-        __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachments, "f").push(...globalAttachments);
+        __classPrivateFieldGet(this, _DefaultAllureStore_globalAttachmentIds, "f").push(...globalAttachmentIds);
         __classPrivateFieldGet(this, _DefaultAllureStore_globalErrors, "f").push(...globalErrors);
         Object.assign(__classPrivateFieldGet(this, _DefaultAllureStore_reportVariables, "f"), reportVariables);
         Object.entries(indexAttachmentByTestResult).forEach(([trId, links]) => {
@@ -629,10 +679,10 @@ export class DefaultAllureStore {
             }
             hidePreviousAttempt(this.indexLatestEnvTestResultByHistoryId, tr);
         });
-        Object.assign(__classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResultsByRules, "f"), qualityGateResultsByRules);
+        __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResults, "f").push(...qualityGateResults);
     }
 }
-_DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_attachments = new WeakMap(), _DefaultAllureStore_attachmentContents = new WeakMap(), _DefaultAllureStore_testCases = new WeakMap(), _DefaultAllureStore_metadata = new WeakMap(), _DefaultAllureStore_history = new WeakMap(), _DefaultAllureStore_known = new WeakMap(), _DefaultAllureStore_fixtures = new WeakMap(), _DefaultAllureStore_defaultLabels = new WeakMap(), _DefaultAllureStore_environment = new WeakMap(), _DefaultAllureStore_environmentsConfig = new WeakMap(), _DefaultAllureStore_reportVariables = new WeakMap(), _DefaultAllureStore_realtimeDispatcher = new WeakMap(), _DefaultAllureStore_realtimeSubscriber = new WeakMap(), _DefaultAllureStore_globalAttachments = new WeakMap(), _DefaultAllureStore_globalErrors = new WeakMap(), _DefaultAllureStore_globalExitCode = new WeakMap(), _DefaultAllureStore_qualityGateResultsByRules = new WeakMap(), _DefaultAllureStore_historyPoints = new WeakMap(), _DefaultAllureStore_environments = new WeakMap(), _DefaultAllureStore_instances = new WeakSet(), _DefaultAllureStore_addEnvironments = function _DefaultAllureStore_addEnvironments(envs) {
+_DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_attachments = new WeakMap(), _DefaultAllureStore_attachmentContents = new WeakMap(), _DefaultAllureStore_testCases = new WeakMap(), _DefaultAllureStore_metadata = new WeakMap(), _DefaultAllureStore_history = new WeakMap(), _DefaultAllureStore_known = new WeakMap(), _DefaultAllureStore_fixtures = new WeakMap(), _DefaultAllureStore_defaultLabels = new WeakMap(), _DefaultAllureStore_environment = new WeakMap(), _DefaultAllureStore_environmentsConfig = new WeakMap(), _DefaultAllureStore_reportVariables = new WeakMap(), _DefaultAllureStore_realtimeDispatcher = new WeakMap(), _DefaultAllureStore_realtimeSubscriber = new WeakMap(), _DefaultAllureStore_globalAttachmentIds = new WeakMap(), _DefaultAllureStore_globalErrors = new WeakMap(), _DefaultAllureStore_globalExitCode = new WeakMap(), _DefaultAllureStore_qualityGateResults = new WeakMap(), _DefaultAllureStore_historyPoints = new WeakMap(), _DefaultAllureStore_environments = new WeakMap(), _DefaultAllureStore_instances = new WeakSet(), _DefaultAllureStore_addEnvironments = function _DefaultAllureStore_addEnvironments(envs) {
     if (__classPrivateFieldGet(this, _DefaultAllureStore_environments, "f").length === 0) {
         __classPrivateFieldGet(this, _DefaultAllureStore_environments, "f").push(DEFAULT_ENVIRONMENT);
     }

package/dist/utils/event.d.ts

@@ -15,14 +15,17 @@ export interface AllureStoreEvents {
     [RealtimeEvents.TestResult]: [string];
     [RealtimeEvents.TestFixtureResult]: [string];
     [RealtimeEvents.AttachmentFile]: [string];
-    [RealtimeEvents.GlobalAttachment]: [ResultFile];
+    [RealtimeEvents.GlobalAttachment]: [{
+        attachment: ResultFile;
+        fileName?: string;
+    }];
     [RealtimeEvents.GlobalExitCode]: [ExitCode];
     [RealtimeEvents.GlobalError]: [TestError];
 }
 export declare class RealtimeEventsDispatcher implements RealtimeEventsDispatcherType {
     #private;
     constructor(emitter: EventEmitter<AllureStoreEvents>);
-    sendGlobalAttachment(attachment: ResultFile): void;
+    sendGlobalAttachment(attachment: ResultFile, fileName?: string): void;
     sendGlobalExitCode(codes: ExitCode): void;
     sendGlobalError(error: TestError): void;
     sendQualityGateResults(payload: QualityGateValidationResult[]): void;
@@ -33,7 +36,10 @@ export declare class RealtimeEventsDispatcher implements RealtimeEventsDispatche
 export declare class RealtimeSubscriber implements RealtimeSubscriberType {
     #private;
     constructor(emitter: EventEmitter<AllureStoreEvents>);
-    onGlobalAttachment(listener: (attachment: ResultFile) => Promise<void>): () => void;
+    onGlobalAttachment(listener: (payload: {
+        attachment: ResultFile;
+        fileName?: string;
+    }) => Promise<void>): () => void;
     onGlobalExitCode(listener: (payload: ExitCode) => Promise<void>): () => void;
     onGlobalError(listener: (error: TestError) => Promise<void>): () => void;
     onQualityGateResults(listener: (payload: QualityGateValidationResult[]) => Promise<void>): () => void;

package/dist/utils/event.js

@@ -27,8 +27,8 @@ export class RealtimeEventsDispatcher {
         _RealtimeEventsDispatcher_emitter.set(this, void 0);
         __classPrivateFieldSet(this, _RealtimeEventsDispatcher_emitter, emitter, "f");
     }
-    sendGlobalAttachment(attachment) {
-        __classPrivateFieldGet(this, _RealtimeEventsDispatcher_emitter, "f").emit(RealtimeEvents.GlobalAttachment, attachment);
+    sendGlobalAttachment(attachment, fileName) {
+        __classPrivateFieldGet(this, _RealtimeEventsDispatcher_emitter, "f").emit(RealtimeEvents.GlobalAttachment, { attachment, fileName });
     }
     sendGlobalExitCode(codes) {
         __classPrivateFieldGet(this, _RealtimeEventsDispatcher_emitter, "f").emit(RealtimeEvents.GlobalExitCode, codes);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/core",
-  "version": "3.0.1",
+  "version": "3.2.0",
   "description": "Collection of generic Allure utilities used across the entire project",
   "keywords": [
     "allure"
@@ -25,25 +25,25 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@allurereport/ci": "3.0.1",
-    "@allurereport/core-api": "3.0.1",
-    "@allurereport/plugin-allure2": "3.0.1",
-    "@allurereport/plugin-api": "3.0.1",
-    "@allurereport/plugin-awesome": "3.0.1",
-    "@allurereport/plugin-classic": "3.0.1",
-    "@allurereport/plugin-csv": "3.0.1",
-    "@allurereport/plugin-dashboard": "3.0.1",
-    "@allurereport/plugin-jira": "3.0.1",
-    "@allurereport/plugin-log": "3.0.1",
-    "@allurereport/plugin-progress": "3.0.1",
-    "@allurereport/plugin-slack": "3.0.1",
-    "@allurereport/plugin-testplan": "3.0.1",
-    "@allurereport/reader": "3.0.1",
-    "@allurereport/reader-api": "3.0.1",
-    "@allurereport/service": "3.0.1",
-    "@allurereport/summary": "3.0.1",
+    "@allurereport/ci": "3.2.0",
+    "@allurereport/core-api": "3.2.0",
+    "@allurereport/plugin-allure2": "3.2.0",
+    "@allurereport/plugin-api": "3.2.0",
+    "@allurereport/plugin-awesome": "3.2.0",
+    "@allurereport/plugin-classic": "3.2.0",
+    "@allurereport/plugin-csv": "3.2.0",
+    "@allurereport/plugin-dashboard": "3.2.0",
+    "@allurereport/plugin-jira": "3.2.0",
+    "@allurereport/plugin-log": "3.2.0",
+    "@allurereport/plugin-progress": "3.2.0",
+    "@allurereport/plugin-slack": "3.2.0",
+    "@allurereport/plugin-testops": "3.2.0",
+    "@allurereport/plugin-testplan": "3.2.0",
+    "@allurereport/reader": "3.2.0",
+    "@allurereport/reader-api": "3.2.0",
+    "@allurereport/service": "3.2.0",
+    "@allurereport/summary": "3.2.0",
     "handlebars": "^4.7.8",
-    "markdown-it": "^14.1.0",
     "node-stream-zip": "^1.15.0",
     "p-limit": "^7.2.0",
     "progress": "^2.0.3",
@@ -55,7 +55,6 @@
     "@stylistic/eslint-plugin": "^2.6.1",
     "@types/eslint": "^8.56.11",
     "@types/handlebars": "^4.1.0",
-    "@types/markdown-it": "^14.1.2",
     "@types/node": "^20.17.9",
     "@types/progress": "^2",
     "@types/zip-stream": "^7.0.0",