@allurereport/core 3.18.0 → 3.19.1

package/dist/utils/event.d.ts

@@ -48,7 +48,7 @@ export declare class RealtimeEventsDispatcher implements RealtimeEventsDispatche
 }
 export declare class RealtimeSubscriber implements RealtimeSubscriberType {
     #private;
-    constructor(emitter: EventEmitter<AllureStoreEvents>);
+    constructor(emitter: EventEmitter<AllureStoreEvents>, beforeTestResults?: () => void);
     onGlobalAttachment(listener: (payload: {
         attachment: ResultFile;
         fileName?: string;

package/dist/utils/event.js

@@ -9,7 +9,7 @@ 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 _RealtimeEventsDispatcher_emitter, _RealtimeSubscriber_instances, _RealtimeSubscriber_emitter, _RealtimeSubscriber_handlers, _RealtimeSubscriber_onEvent, _RealtimeSubscriber_onBatchedEvent, _RealtimeSubscriber_createBatchHandler, _RealtimeSubscriber_runBatchHandler, _RealtimeSubscriber_disposeBatchHandler;
+var _RealtimeEventsDispatcher_emitter, _RealtimeSubscriber_instances, _RealtimeSubscriber_emitter, _RealtimeSubscriber_beforeTestResults, _RealtimeSubscriber_handlers, _RealtimeSubscriber_onEvent, _RealtimeSubscriber_onBatchedEvent, _RealtimeSubscriber_createBatchHandler, _RealtimeSubscriber_runBatchHandler, _RealtimeSubscriber_disposeBatchHandler;
 import console from "node:console";
 import { setTimeout } from "node:timers/promises";
 export var RealtimeEvents;
@@ -77,11 +77,13 @@ export class RealtimeEventsDispatcher {
 }
 _RealtimeEventsDispatcher_emitter = new WeakMap();
 export class RealtimeSubscriber {
-    constructor(emitter) {
+    constructor(emitter, beforeTestResults) {
         _RealtimeSubscriber_instances.add(this);
         _RealtimeSubscriber_emitter.set(this, void 0);
+        _RealtimeSubscriber_beforeTestResults.set(this, void 0);
         _RealtimeSubscriber_handlers.set(this, []);
         __classPrivateFieldSet(this, _RealtimeSubscriber_emitter, emitter, "f");
+        __classPrivateFieldSet(this, _RealtimeSubscriber_beforeTestResults, beforeTestResults, "f");
     }
     onGlobalAttachment(listener) {
         return __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_onEvent).call(this, RealtimeEvents.GlobalAttachment, listener);
@@ -105,7 +107,10 @@ export class RealtimeSubscriber {
         return __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_onEvent).call(this, RealtimeEvents.QualityGateResults, listener);
     }
     onTestResults(listener, options = {}) {
-        return __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_onBatchedEvent).call(this, RealtimeEvents.TestResult, listener, options);
+        return __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_onBatchedEvent).call(this, RealtimeEvents.TestResult, (trIds) => {
+            __classPrivateFieldGet(this, _RealtimeSubscriber_beforeTestResults, "f")?.call(this);
+            return listener(trIds);
+        }, options);
     }
     onTestFixtureResults(listener, options = {}) {
         return __classPrivateFieldGet(this, _RealtimeSubscriber_instances, "m", _RealtimeSubscriber_onBatchedEvent).call(this, RealtimeEvents.TestFixtureResult, listener, options);
@@ -121,7 +126,7 @@ export class RealtimeSubscriber {
         __classPrivateFieldSet(this, _RealtimeSubscriber_handlers, [], "f");
     }
 }
-_RealtimeSubscriber_emitter = new WeakMap(), _RealtimeSubscriber_handlers = new WeakMap(), _RealtimeSubscriber_instances = new WeakSet(), _RealtimeSubscriber_onEvent = function _RealtimeSubscriber_onEvent(event, listener) {
+_RealtimeSubscriber_emitter = new WeakMap(), _RealtimeSubscriber_beforeTestResults = new WeakMap(), _RealtimeSubscriber_handlers = new WeakMap(), _RealtimeSubscriber_instances = new WeakSet(), _RealtimeSubscriber_onEvent = function _RealtimeSubscriber_onEvent(event, listener) {
     const handler = createListenerHandler(listener);
     __classPrivateFieldGet(this, _RealtimeSubscriber_emitter, "f").on(event, handler);
     return () => {

package/dist/utils/flaky.d.ts

@@ -1,2 +1,2 @@
-import type { HistoryTestResult, TestResult } from "@allurereport/core-api";
-export declare const isFlaky: (tr: TestResult, history: HistoryTestResult[]) => boolean;
+import { type FlakyDetectionConfig, type HistoryTestResult, type TestResult } from "@allurereport/core-api";
+export declare const createFlakyDetector: ({ historyDepth, includePassedTests, }?: FlakyDetectionConfig) => ((tr: TestResult, history: HistoryTestResult[]) => boolean);

package/dist/utils/flaky.js

@@ -1,12 +1,40 @@
-const MAX_LAST_HISTORY_SIZE = 5;
+import { DEFAULT_ENVIRONMENT, } from "@allurereport/core-api";
+const DEFAULT_HISTORY_DEPTH = 5;
+const TRANSITION_HALF_LIFE = 2;
+const STABILITY_PRIOR_WEIGHT = 3;
+const FLAKY_SCORE_THRESHOLD = 30;
 const badStatuses = ["failed", "broken"];
-const isAllureClassicFlaky = (tr, history) => {
-    if (history.length === 0 || !badStatuses.includes(tr.status)) {
+const isFlakyByWeightedTransitions = (tr, history, historyDepth, includePassedTests) => {
+    const currentPassed = tr.status === "passed";
+    const isEligibleStatus = badStatuses.includes(tr.status) || (includePassedTests && currentPassed);
+    if (historyDepth === -1 || !isEligibleStatus) {
         return false;
     }
-    const limitedLastHistory = history.slice(0, MAX_LAST_HISTORY_SIZE);
-    const limitedLastHistoryStatuses = limitedLastHistory.map((h) => h.status);
-    return (limitedLastHistoryStatuses.includes("passed") &&
-        limitedLastHistoryStatuses.indexOf("passed") < limitedLastHistoryStatuses.lastIndexOf("failed"));
+    let previousPassed = currentPassed;
+    let comparisons = 0;
+    let weightedTransitions = 0;
+    let totalWeight = 0;
+    for (const result of history) {
+        if (historyDepth !== 0 && comparisons >= historyDepth) {
+            break;
+        }
+        if (result.id === tr.id ||
+            (result.environment ?? DEFAULT_ENVIRONMENT) !== (tr.environment ?? DEFAULT_ENVIRONMENT) ||
+            (result.status !== "passed" && !badStatuses.includes(result.status))) {
+            continue;
+        }
+        const passed = result.status === "passed";
+        const weight = 2 ** (-comparisons / TRANSITION_HALF_LIFE);
+        if (passed !== previousPassed) {
+            weightedTransitions += weight;
+        }
+        totalWeight += weight;
+        previousPassed = passed;
+        comparisons++;
+    }
+    const score = (100 * weightedTransitions) / (STABILITY_PRIOR_WEIGHT + totalWeight);
+    return score >= FLAKY_SCORE_THRESHOLD;
+};
+export const createFlakyDetector = ({ historyDepth = DEFAULT_HISTORY_DEPTH, includePassedTests = false, } = {}) => {
+    return (tr, history) => isFlakyByWeightedTransitions(tr, history, historyDepth, includePassedTests);
 };
-export const isFlaky = (tr, history) => tr.flaky || isAllureClassicFlaky(tr, history);

package/dist/utils/perf.d.ts

@@ -1,18 +1,12 @@
 import type { AllurePerformanceResult } from "@allurereport/core-api";
 export declare const PERF_METRICS_FILE = "performance.json";
 export declare const perfMetricsFileName: (reportUuid: string) => string;
-export type PerfMetricSpan = {
-    name: string;
-    startTimeMs: number;
-    durationMs: number;
-};
-export type PerfMetricSummary = {
-    name: string;
-    count: number;
-    totalMs: number;
-    minMs: number;
-    maxMs: number;
-    avgMs: number;
+type PerfMetricMetadata = {
+    title?: string;
+    unit?: string;
+    group?: string;
+    groupTitle?: string;
+    better?: "neutral";
 };
 export declare const PERF_METRIC_NAMES: {
     readonly allureTotal: "allure.total";
@@ -22,17 +16,35 @@ export declare const PERF_METRIC_NAMES: {
     readonly restoreStateStoreRestore: "restoreState.storeRestore";
     readonly generateTotal: "generate.total";
     readonly generateReadResults: "generate.readResults";
+    readonly generateReadResultsXcresultCheck: "generate.readResults.xcresultCheck";
+    readonly generateReadResultsReaddir: "generate.readResults.readdir";
+    readonly generateReadResultsFiles: "generate.readResults.files";
+    readonly generateReadResultsRealpath: "generate.readResults.realpath";
+    readonly generateReadResultsReaderRead: "generate.readResults.reader.read";
     readonly generatePluginsDone: "generate.plugins.done";
+    readonly storeVisitTestResultConvert: "store.visitTestResult.convert";
+    readonly storeVisitTestResultDefaultLabels: "store.visitTestResult.defaultLabels";
+    readonly storeVisitTestResultEnvironment: "store.visitTestResult.environment";
+    readonly storeVisitTestResultRetry: "store.visitTestResult.retry";
+    readonly storeVisitTestResultHistory: "store.visitTestResult.history";
+    readonly storeVisitTestResultResolution: "store.visitTestResult.resolution";
+    readonly storeVisitTestResultIndexes: "store.visitTestResult.indexes";
+    readonly storeVisitAttachmentFileMetadata: "store.visitAttachmentFile.metadata";
     readonly publishUploadTotal: "publish.upload.total";
     readonly summaryGenerate: "summary.generate";
 };
 export declare const PERF_METRIC_PREFIXES: {
+    readonly generatePlugin: "generate.plugin.";
     readonly generatePluginDone: "generate.plugin.done.";
     readonly publishUploadPlugin: "publish.upload.plugin.";
 };
 export declare const isPerfMetricsEnabled: () => boolean;
 export declare const startPerfSpan: (name: string) => (() => void);
 export declare const measurePerf: <T>(name: string, fn: () => Promise<T>) => Promise<T>;
+export declare const measurePerfAggregate: <T>(name: string, fn: () => Promise<T>) => Promise<T>;
+export declare const measurePerfAggregateSync: <T>(name: string, fn: () => T) => T;
+export declare const incrementPerfCounter: (name: string, value?: number, metadata?: PerfMetricMetadata) => void;
 export declare const getPerfMetricsResults: () => AllurePerformanceResult[];
 export declare const writePerfMetrics: (output: string, fileName?: string) => Promise<boolean>;
 export declare const resetPerfMetrics: () => void;
+export {};

package/dist/utils/perf.js

@@ -7,6 +7,8 @@ export const perfMetricsFileName = (reportUuid) => `${reportUuid}-perf.json`;
 const MARK_PREFIX = "allure:perf:";
 const ENABLED_VALUES = new Set(["1", "true", "yes", "on"]);
 const SPANS = [];
+const AGGREGATES = new Map();
+const COUNTERS = new Map();
 const MARKS = new Set();
 const MEASURES = new Set();
 let sequence = 0;
@@ -19,28 +21,46 @@ export const PERF_METRIC_NAMES = {
     restoreStateStoreRestore: "restoreState.storeRestore",
     generateTotal: "generate.total",
     generateReadResults: "generate.readResults",
+    generateReadResultsXcresultCheck: "generate.readResults.xcresultCheck",
+    generateReadResultsReaddir: "generate.readResults.readdir",
+    generateReadResultsFiles: "generate.readResults.files",
+    generateReadResultsRealpath: "generate.readResults.realpath",
+    generateReadResultsReaderRead: "generate.readResults.reader.read",
     generatePluginsDone: "generate.plugins.done",
+    storeVisitTestResultConvert: "store.visitTestResult.convert",
+    storeVisitTestResultDefaultLabels: "store.visitTestResult.defaultLabels",
+    storeVisitTestResultEnvironment: "store.visitTestResult.environment",
+    storeVisitTestResultRetry: "store.visitTestResult.retry",
+    storeVisitTestResultHistory: "store.visitTestResult.history",
+    storeVisitTestResultResolution: "store.visitTestResult.resolution",
+    storeVisitTestResultIndexes: "store.visitTestResult.indexes",
+    storeVisitAttachmentFileMetadata: "store.visitAttachmentFile.metadata",
     publishUploadTotal: "publish.upload.total",
     summaryGenerate: "summary.generate",
 };
 export const PERF_METRIC_PREFIXES = {
+    generatePlugin: "generate.plugin.",
     generatePluginDone: "generate.plugin.done.",
     publishUploadPlugin: "publish.upload.plugin.",
 };
-const getCoveredDurationSummary = () => {
-    if (SPANS.length === 0) {
+const getCoveredTiming = () => {
+    const timings = [
+        ...SPANS.map(({ startTimeMs, durationMs }) => ({
+            startTimeMs,
+            stopTimeMs: startTimeMs + durationMs,
+        })),
+        ...AGGREGATES.values(),
+        ...COUNTERS.values(),
+    ];
+    if (timings.length === 0) {
         return undefined;
     }
-    const startTimeMs = Math.min(...SPANS.map(({ startTimeMs }) => startTimeMs));
-    const endTimeMs = Math.max(...SPANS.map(({ startTimeMs, durationMs }) => startTimeMs + durationMs));
-    const durationMs = round(endTimeMs - startTimeMs);
+    const startTimeMs = Math.min(...timings.map(({ startTimeMs }) => startTimeMs));
+    const stopTimeMs = Math.max(...timings.map(({ stopTimeMs }) => stopTimeMs));
     return {
-        name: PERF_METRIC_NAMES.allureTotal,
-        count: 1,
-        totalMs: durationMs,
-        minMs: durationMs,
-        maxMs: durationMs,
-        avgMs: durationMs,
+        startTimeMs,
+        stopTimeMs,
+        durationMs: round(stopTimeMs - startTimeMs),
     };
 };
 export const isPerfMetricsEnabled = () => ENABLED_VALUES.has((process.env.ALLURE_PERF_METRICS ?? "").toLowerCase());
@@ -91,8 +111,80 @@ export const measurePerf = async (name, fn) => {
         end();
     }
 };
+const recordPerfTiming = (name, durationMs, startTimeMs) => {
+    if (!isPerfMetricsEnabled()) {
+        return;
+    }
+    const current = AGGREGATES.get(name);
+    if (!current) {
+        AGGREGATES.set(name, {
+            name,
+            count: 1,
+            totalMs: durationMs,
+            startTimeMs,
+            stopTimeMs: startTimeMs + durationMs,
+        });
+        return;
+    }
+    current.count += 1;
+    current.totalMs += durationMs;
+    current.startTimeMs = Math.min(current.startTimeMs, startTimeMs);
+    current.stopTimeMs = Math.max(current.stopTimeMs, startTimeMs + durationMs);
+};
+export const measurePerfAggregate = async (name, fn) => {
+    if (!isPerfMetricsEnabled()) {
+        return fn();
+    }
+    const startTimeMs = performance.now();
+    try {
+        return await fn();
+    }
+    finally {
+        recordPerfTiming(name, performance.now() - startTimeMs, startTimeMs);
+    }
+};
+export const measurePerfAggregateSync = (name, fn) => {
+    if (!isPerfMetricsEnabled()) {
+        return fn();
+    }
+    const startTimeMs = performance.now();
+    try {
+        return fn();
+    }
+    finally {
+        recordPerfTiming(name, performance.now() - startTimeMs, startTimeMs);
+    }
+};
+export const incrementPerfCounter = (name, value = 1, metadata) => {
+    if (!isPerfMetricsEnabled()) {
+        return;
+    }
+    const timeMs = performance.now();
+    const current = COUNTERS.get(name);
+    if (!current) {
+        COUNTERS.set(name, {
+            name,
+            value,
+            startTimeMs: timeMs,
+            stopTimeMs: timeMs,
+            ...(metadata ? { metadata } : {}),
+        });
+        return;
+    }
+    current.value += value;
+    current.stopTimeMs = timeMs;
+    current.metadata ?? (current.metadata = metadata);
+};
+const metricResult = (key, value, startTimeMs, stopTimeMs, metadata) => ({
+    id: randomUUID(),
+    key,
+    value: round(value),
+    start: round(performance.timeOrigin + startTimeMs),
+    stop: round(performance.timeOrigin + stopTimeMs),
+    ...metadata,
+});
 export const getPerfMetricsResults = () => {
-    const totalSummary = getCoveredDurationSummary();
+    const coveredTiming = getCoveredTiming();
     const results = SPANS.map((span) => ({
         id: randomUUID(),
         key: span.name,
@@ -100,15 +192,21 @@ export const getPerfMetricsResults = () => {
         start: round(performance.timeOrigin + span.startTimeMs),
         stop: round(performance.timeOrigin + span.startTimeMs + span.durationMs),
     }));
-    if (totalSummary) {
+    if (coveredTiming) {
         results.unshift({
             id: randomUUID(),
             key: PERF_METRIC_NAMES.allureTotal,
-            value: totalSummary.avgMs,
-            start: round(performance.timeOrigin + Math.min(...SPANS.map(({ startTimeMs }) => startTimeMs))),
-            stop: round(performance.timeOrigin + Math.max(...SPANS.map(({ startTimeMs, durationMs }) => startTimeMs + durationMs))),
+            value: coveredTiming.durationMs,
+            start: round(performance.timeOrigin + coveredTiming.startTimeMs),
+            stop: round(performance.timeOrigin + coveredTiming.stopTimeMs),
         });
     }
+    for (const aggregate of AGGREGATES.values()) {
+        results.push(metricResult(`${aggregate.name}.totalMs`, aggregate.totalMs, aggregate.startTimeMs, aggregate.stopTimeMs), metricResult(`${aggregate.name}.avgMs`, aggregate.totalMs / aggregate.count, aggregate.startTimeMs, aggregate.stopTimeMs));
+    }
+    for (const counter of COUNTERS.values()) {
+        results.push(metricResult(counter.name, counter.value, counter.startTimeMs, counter.stopTimeMs, counter.metadata));
+    }
     return results;
 };
 export const writePerfMetrics = async (output, fileName = PERF_METRICS_FILE) => {
@@ -123,6 +221,8 @@ export const writePerfMetrics = async (output, fileName = PERF_METRICS_FILE) =>
 };
 export const resetPerfMetrics = () => {
     SPANS.length = 0;
+    AGGREGATES.clear();
+    COUNTERS.clear();
     sequence = 0;
     for (const mark of MARKS) {
         performance.clearMarks(mark);

package/dist/utils/realtimeChannel.d.ts

@@ -3,6 +3,7 @@ export declare class RealtimeChannel {
     #private;
     readonly dispatcher: RealtimeEventsDispatcher;
     readonly subscriber: RealtimeSubscriber;
+    constructor(beforeTestResults?: () => void);
     onResultLikeChanged(listener: () => void): () => void;
     close(): void;
 }

package/dist/utils/realtimeChannel.js

@@ -7,10 +7,10 @@ var _RealtimeChannel_emitter;
 import { EventEmitter } from "node:events";
 import { RealtimeEvents, RealtimeEventsDispatcher, RealtimeSubscriber } from "./event.js";
 export class RealtimeChannel {
-    constructor() {
+    constructor(beforeTestResults) {
         _RealtimeChannel_emitter.set(this, new EventEmitter());
         this.dispatcher = new RealtimeEventsDispatcher(__classPrivateFieldGet(this, _RealtimeChannel_emitter, "f"));
-        this.subscriber = new RealtimeSubscriber(__classPrivateFieldGet(this, _RealtimeChannel_emitter, "f"));
+        this.subscriber = new RealtimeSubscriber(__classPrivateFieldGet(this, _RealtimeChannel_emitter, "f"), beforeTestResults);
     }
     onResultLikeChanged(listener) {
         __classPrivateFieldGet(this, _RealtimeChannel_emitter, "f").on(RealtimeEvents.TestResult, listener);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/core",
-  "version": "3.18.0",
+  "version": "3.19.1",
   "description": "Collection of generic Allure utilities used across the entire project",
   "keywords": [
     "allure"
@@ -25,26 +25,26 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/ci": "3.18.0",
-    "@allurereport/cli-commons": "3.18.0",
-    "@allurereport/core-api": "3.18.0",
-    "@allurereport/plugin-agent": "3.18.0",
-    "@allurereport/plugin-allure2": "3.18.0",
-    "@allurereport/plugin-api": "3.18.0",
-    "@allurereport/plugin-awesome": "3.18.0",
-    "@allurereport/plugin-classic": "3.18.0",
-    "@allurereport/plugin-csv": "3.18.0",
-    "@allurereport/plugin-dashboard": "3.18.0",
-    "@allurereport/plugin-jira": "3.18.0",
-    "@allurereport/plugin-log": "3.18.0",
-    "@allurereport/plugin-progress": "3.18.0",
-    "@allurereport/plugin-slack": "3.18.0",
-    "@allurereport/plugin-testops": "3.18.0",
-    "@allurereport/plugin-testplan": "3.18.0",
-    "@allurereport/reader": "3.18.0",
-    "@allurereport/reader-api": "3.18.0",
-    "@allurereport/service": "3.18.0",
-    "@allurereport/summary": "3.18.0",
+    "@allurereport/ci": "3.19.1",
+    "@allurereport/cli-commons": "3.19.1",
+    "@allurereport/core-api": "3.19.1",
+    "@allurereport/plugin-agent": "3.19.1",
+    "@allurereport/plugin-allure2": "3.19.1",
+    "@allurereport/plugin-api": "3.19.1",
+    "@allurereport/plugin-awesome": "3.19.1",
+    "@allurereport/plugin-classic": "3.19.1",
+    "@allurereport/plugin-csv": "3.19.1",
+    "@allurereport/plugin-dashboard": "3.19.1",
+    "@allurereport/plugin-jira": "3.19.1",
+    "@allurereport/plugin-log": "3.19.1",
+    "@allurereport/plugin-progress": "3.19.1",
+    "@allurereport/plugin-slack": "3.19.1",
+    "@allurereport/plugin-testops": "3.19.1",
+    "@allurereport/plugin-testplan": "3.19.1",
+    "@allurereport/reader": "3.19.1",
+    "@allurereport/reader-api": "3.19.1",
+    "@allurereport/service": "3.19.1",
+    "@allurereport/summary": "3.19.1",
     "glob": "^13.0.6",
     "handlebars": "^4.7.9",
     "jiti": "^2.5.1",
@@ -58,7 +58,7 @@
     "@types/node": "^20",
     "@types/zip-stream": "^7.0.0",
     "@vitest/runner": "^2",
-    "@vitest/snapshot": "^2.1.9",
+    "@vitest/snapshot": "^5.0.1",
     "allure-js-commons": "^3",
     "allure-vitest": "^3",
     "rimraf": "^6",