@allurereport/core 3.17.0 → 3.19.0

package/dist/config.d.ts

@@ -9,11 +9,11 @@ export interface ConfigOverride {
     port?: Config["port"];
     hideLabels?: Config["hideLabels"];
     historyPath?: Config["historyPath"];
+    historyBaseUrl?: Config["historyBaseUrl"];
     historyLimit?: Config["historyLimit"];
     resolutions?: Pick<NonNullable<Config["resolutions"]>, "knownIssuesPath">;
     plugins?: Config["plugins"];
 }
-export declare const parseIntegerConfigValue: (value: unknown, defaultValue: number, minValue: number) => number;
 export declare const isAgentDescriptor: (value: string | undefined) => value is "agent" | "@allurereport/plugin-agent";
 export declare const hasConfiguredAgent: (plugins: Record<string, PluginDescriptor>) => boolean;
 export declare const assertValidPluginId: (id: string) => void;

package/dist/config.js

@@ -1,7 +1,7 @@
 import { readFile, stat } from "node:fs/promises";
 import { extname, resolve } from "node:path";
 import * as process from "node:process";
-import { validateEnvironmentName } from "@allurereport/core-api";
+import { parseIntegerConfigValue, validateEnvironmentName } from "@allurereport/core-api";
 import { createJiti } from "jiti";
 import { parse } from "yaml";
 import { FileSystemReportFiles } from "./plugin.js";
@@ -23,16 +23,8 @@ const CONFIG_FILENAMES = [
     "allurerc.yml",
 ];
 const DEFAULT_CONFIG = {};
-const DEFAULT_ALLURE_SERVICE_UPLOAD_CONCURRENCY = 100;
 const DEFAULT_ALLURE_SERVICE_UPLAOD_MAX_ATTEMPTS = 5;
 const DEFAULT_ALLURE_SERVICE_UPLOAD_MAX_SIMULTANEOUS_FAILURES = 5;
-export const parseIntegerConfigValue = (value, defaultValue, minValue) => {
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-        return defaultValue;
-    }
-    const normalized = Math.floor(value);
-    return normalized >= minValue ? normalized : defaultValue;
-};
 export const isAgentDescriptor = (value) => {
     return value === "agent" || value === "@allurereport/plugin-agent";
 };
@@ -97,7 +89,9 @@ export const validateConfig = (config) => {
         "port",
         "hideLabels",
         "historyPath",
+        "historyBaseUrl",
         "historyLimit",
+        "flakyDetection",
         "resolutions",
         "plugins",
         "defaultLabels",
@@ -112,6 +106,7 @@ export const validateConfig = (config) => {
         "categories",
         "globalAttachments",
         "resultsDir",
+        "dump",
     ];
     const unsupportedFields = Object.keys(config).filter((key) => !supportedFields.includes(key));
     return {
@@ -190,19 +185,34 @@ const resolveConfigEnvironments = (config) => {
         allowedEnvironments,
     };
 };
+const validateFlakyDetectionConfig = (config) => {
+    if (config === undefined) {
+        return;
+    }
+    const { historyDepth, includePassedTests } = config;
+    if (historyDepth !== undefined && (!Number.isInteger(historyDepth) || historyDepth < -1)) {
+        throw new Error("flakyDetection.historyDepth must be an integer greater than or equal to -1");
+    }
+    if (includePassedTests !== undefined && typeof includePassedTests !== "boolean") {
+        throw new TypeError("flakyDetection.includePassedTests must be a boolean");
+    }
+};
 export const resolveConfig = async (config, override = {}) => {
     const validationResult = validateConfig(config);
     if (!validationResult.valid) {
         throw new Error(`The provided Allure config contains unsupported fields: ${validationResult.fields.join(", ")}`);
     }
     validateResolutionsConfig(config.resolutions);
+    validateFlakyDetectionConfig(config.flakyDetection);
     const { environments, environment, allowedEnvironments } = resolveConfigEnvironments(config);
     const name = override.name ?? config.name ?? "Allure Report";
     const open = override.open ?? config.open ?? false;
     const port = override.port ?? config.port ?? undefined;
     const hideLabels = override.hideLabels ?? config.hideLabels;
     const historyPath = override.historyPath ?? config.historyPath;
+    const historyBaseUrl = override.historyBaseUrl ?? config.historyBaseUrl;
     const historyLimit = override.historyLimit ?? config.historyLimit;
+    const dump = config.dump;
     const appendHistory = config.appendHistory ?? true;
     const configuredKnownIssuesPath = override.resolutions?.knownIssuesPath ?? config.resolutions?.knownIssuesPath;
     const knownIssuesPathInput = configuredKnownIssuesPath ?? (config.resolutions ? DEFAULT_KNOWN_ISSUES_PATH : undefined);
@@ -235,6 +245,7 @@ export const resolveConfig = async (config, override = {}) => {
             };
         pluginInstances = await resolvePlugins(pluginsWithAgent);
     }
+    const uploadConcurrency = parseIntegerConfigValue(config.allureService?.uploadConcurrency, 1);
     return {
         name,
         cwd,
@@ -249,7 +260,10 @@ export const resolveConfig = async (config, override = {}) => {
         environments,
         appendHistory,
         historyLimit,
+        flakyDetection: config.flakyDetection,
         historyPath: historyPath ? resolve(historyPath) : undefined,
+        historyBaseUrl,
+        dump,
         reportFiles: new FileSystemReportFiles(output),
         plugins: pluginInstances,
         defaultLabels: config.defaultLabels ?? {},
@@ -259,9 +273,11 @@ export const resolveConfig = async (config, override = {}) => {
             ? {
                 accessToken: config.allureService.accessToken,
                 private: config.allureService.private,
-                uploadConcurrency: parseIntegerConfigValue(config.allureService.uploadConcurrency, DEFAULT_ALLURE_SERVICE_UPLOAD_CONCURRENCY, 1),
-                uploadMaxAttempts: parseIntegerConfigValue(config.allureService.uploadMaxAttempts, DEFAULT_ALLURE_SERVICE_UPLAOD_MAX_ATTEMPTS, 1),
-                uploadMaxSimultaneousFailures: parseIntegerConfigValue(config.allureService.uploadMaxSimultaneousFailures, DEFAULT_ALLURE_SERVICE_UPLOAD_MAX_SIMULTANEOUS_FAILURES, 0),
+                ...(uploadConcurrency === undefined ? {} : { uploadConcurrency }),
+                uploadMaxAttempts: parseIntegerConfigValue(config.allureService.uploadMaxAttempts, 1) ??
+                    DEFAULT_ALLURE_SERVICE_UPLAOD_MAX_ATTEMPTS,
+                uploadMaxSimultaneousFailures: parseIntegerConfigValue(config.allureService.uploadMaxSimultaneousFailures, 0) ??
+                    DEFAULT_ALLURE_SERVICE_UPLOAD_MAX_SIMULTANEOUS_FAILURES,
             }
             : undefined,
         categories: config.categories,

package/dist/history.d.ts

@@ -1,4 +1,6 @@
 import { type AllureHistory, type HistoryDataPoint, type MetricSample, type TestCase, type TestResult } from "@allurereport/core-api";
+export declare const normalizeHistoryBaseUrl: (historyBaseUrl: string) => string;
+export declare const setHistoryDataPointUrl: (point: HistoryDataPoint, url: string) => HistoryDataPoint;
 export declare const createHistory: (reportUuid: string, reportName: string | undefined, testCases: TestCase[], testResults: TestResult[], remoteUrl?: string, metrics?: MetricSample[]) => HistoryDataPoint;
 export declare class AllureLocalHistory implements AllureHistory {
     #private;
@@ -7,6 +9,7 @@ export declare class AllureLocalHistory implements AllureHistory {
         historyPath: string;
         limit?: number;
     });
+    resolveTestResultUrl(historyUrl: string, pluginId: string, historicalResultId: string): string;
     readHistory(): Promise<HistoryDataPoint[]>;
     appendHistory(data: HistoryDataPoint): Promise<void>;
 }

package/dist/history.js

@@ -19,8 +19,8 @@ import { normalizeHistoryDataPointUrls, } from "@allurereport/core-api";
 import { isFileNotFoundError } from "./utils/misc.js";
 const createHistoryItems = (testResults, remoteUrl) => {
     return testResults
-        .filter((tr) => tr.historyId)
-        .map(({ id, name, fullName, environment, historyId, status, error: { message, trace } = {}, start, stop, duration, labels, }) => {
+        .filter((tr) => tr.retryHash)
+        .map(({ id, name, fullName, environment, retryHash, status, error: { message, trace } = {}, start, stop, duration, labels, }) => {
         return {
             id,
             name,
@@ -34,12 +34,12 @@ const createHistoryItems = (testResults, remoteUrl) => {
             duration,
             labels,
             url: remoteUrl,
-            historyId: historyId,
+            retryHash: retryHash,
             reportLinks: [],
         };
     })
         .reduce((acc, item) => {
-        acc[item.historyId] = item;
+        acc[item.retryHash] = item;
         return acc;
     }, {});
 };
@@ -53,6 +53,28 @@ const metricsToHistoryValues = (metrics) => {
     }
     return Object.fromEntries([...grouped.entries()].map(([key, values]) => [key, values.reduce((acc, value) => acc + value, 0) / values.length]));
 };
+export const normalizeHistoryBaseUrl = (historyBaseUrl) => {
+    let url;
+    try {
+        url = new URL(historyBaseUrl);
+    }
+    catch (cause) {
+        throw new Error(`Invalid historyBaseUrl ${JSON.stringify(historyBaseUrl)}: expected an absolute URL`, { cause });
+    }
+    if (url.href.includes("#")) {
+        throw new Error(`Invalid historyBaseUrl ${JSON.stringify(historyBaseUrl)}: fragments are not allowed`);
+    }
+    if (/\.html\/?$/iu.test(url.pathname)) {
+        throw new Error(`Invalid historyBaseUrl ${JSON.stringify(historyBaseUrl)}: expected a base URL, not an HTML document`);
+    }
+    url.pathname = `${url.pathname.replace(/\/+$/u, "")}/`;
+    return url.toString();
+};
+export const setHistoryDataPointUrl = (point, url) => ({
+    ...point,
+    url,
+    testResults: Object.fromEntries(Object.entries(point.testResults).map(([historyId, item]) => [historyId, { ...item, url }])),
+});
 export const createHistory = (reportUuid, reportName = "Allure Report", testCases, testResults, remoteUrl = "", metrics = []) => {
     const knownTestCaseIds = testCases.map((tc) => tc.id);
     return {
@@ -138,6 +160,17 @@ export class AllureLocalHistory {
                 `doesn't match the actual number ${actualBytes}`);
         });
     }
+    resolveTestResultUrl(historyUrl, pluginId, historicalResultId) {
+        if (!historyUrl) {
+            return "";
+        }
+        const url = new URL(historyUrl);
+        if (url.pathname.endsWith("/")) {
+            url.pathname = `${url.pathname}${pluginId}/index.html`;
+        }
+        url.hash = historicalResultId;
+        return url.toString();
+    }
     async readHistory() {
         if (__classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f").length > 0) {
             return __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f");
@@ -174,15 +207,14 @@ export class AllureLocalHistory {
         const { limit } = this.params;
         await mkdir(parentDir, { recursive: true });
         const { file: historyFile, exists: historyExists } = await __classPrivateFieldGet(this, _AllureLocalHistory_ensureFileOpenedToAppend, "f").call(this, fullPath);
+        let dst;
         try {
-            const dst = historyFile.createWriteStream({ encoding: "utf-8", start: 0, autoClose: false });
-            if (limit === 0 && historyExists) {
-                await historyFile.truncate(0);
-                return;
-            }
-            if (limit === 0 && !historyExists) {
+            if (limit === 0) {
+                if (historyExists)
+                    await historyFile.truncate(0);
                 return;
             }
+            dst = historyFile.createWriteStream({ encoding: "utf-8", start: 0, autoClose: false });
             if (historyExists) {
                 const start = await __classPrivateFieldGet(this, _AllureLocalHistory_findFirstEntryAddress, "f").call(this, historyFile, limit ? limit - 1 : undefined);
                 const src = historyFile.createReadStream({ start, autoClose: false });
@@ -195,7 +227,11 @@ export class AllureLocalHistory {
             }
         }
         finally {
-            await historyFile.close();
+            const closing = historyFile.close();
+            if (historyFile.fd !== -1) {
+                dst?.destroy();
+            }
+            await closing;
             if (limit !== 0) {
                 __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f").push(normalizedData);
             }

package/dist/index.d.ts

@@ -11,4 +11,4 @@ export * from "./resolutions.js";
 export { resolveConfig, readConfig, readRawConfig, getPluginInstance } from "./config.js";
 export * from "./report.js";
 export * from "./plugin.js";
-export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, metricMaxRule, metricMinRule, metricMaxDeltaRule, metricMaxDeltaPercentRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";
+export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, metricMaxRule, metricMinRule, metricMaxDeltaRule, metricMaxDeltaPercentRule, convertQualityGateResultsToTestErrors, filterFailedQualityGateResults, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/index.js

@@ -10,4 +10,4 @@ export * from "./resolutions.js";
 export { resolveConfig, readConfig, readRawConfig, getPluginInstance } from "./config.js";
 export * from "./report.js";
 export * from "./plugin.js";
-export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, metricMaxRule, metricMinRule, metricMaxDeltaRule, metricMaxDeltaPercentRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";
+export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, metricMaxRule, metricMinRule, metricMaxDeltaRule, metricMaxDeltaPercentRule, convertQualityGateResultsToTestErrors, filterFailedQualityGateResults, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/qualityGate/qualityGate.d.ts

@@ -1,5 +1,6 @@
 import { type MetricSample, type TestError, type TestResult } from "@allurereport/core-api";
 import type { QualityGateConfig, QualityGateMetricHistoryPoint, QualityGateValidationResult } from "@allurereport/plugin-api";
+export declare const filterFailedQualityGateResults: (results: QualityGateValidationResult[]) => QualityGateValidationResult[];
 export declare const stringifyQualityGateResults: (results: QualityGateValidationResult[]) => string;
 export declare const convertQualityGateResultsToTestErrors: (results: QualityGateValidationResult[]) => TestError[];
 export declare class QualityGateState {

package/dist/qualityGate/qualityGate.js

@@ -4,25 +4,29 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _QualityGateState_state, _QualityGateState_processedTestResultIds;
-import { gray, red } from "yoctocolors";
+import { bold, gray, red } from "yoctocolors";
 import { isIgnoredFailure } from "../resolutions.js";
 import { qualityGateDefaultRules } from "./rules.js";
+export const filterFailedQualityGateResults = (results) => results.filter(({ success }) => !success);
+const formatQualityGateValue = (value) => (Array.isArray(value) ? value.join(", ") : String(value));
+const defaultSuccessMessage = ({ actual, expected }) => `The rule has been passed; actual ${bold(formatQualityGateValue(actual))}, expected ${bold(formatQualityGateValue(expected))}`;
 export const stringifyQualityGateResults = (results) => {
-    if (results.length === 0) {
+    const failedResults = filterFailedQualityGateResults(results);
+    if (failedResults.length === 0) {
         return "";
     }
     const lines = [red("Quality Gate failed with following issues:")];
-    const maxMessageLength = Math.max(...results.map((r) => r.message.length));
+    const maxMessageLength = Math.max(...failedResults.map((r) => r.message.length));
     lines.push("");
-    results.forEach((result) => {
+    failedResults.forEach((result) => {
         lines.push(` ${red("⨯")} ${result.message.padEnd(maxMessageLength, " ")}    ${gray(result.rule)}`);
     });
     lines.push("");
-    lines.push(red(`${results.length} quality gate rules have been failed.`));
+    lines.push(red(`${failedResults.length} quality gate rules have been failed.`));
     return lines.join("\n");
 };
 export const convertQualityGateResultsToTestErrors = (results) => {
-    return results.map((result) => ({
+    return filterFailedQualityGateResults(results).map((result) => ({
         message: `Quality Gate (${result.rule}): ${result.message}`,
         actual: result.actual,
         expected: result.expected,
@@ -67,7 +71,7 @@ export class QualityGate {
             }
             trsToValidateById.set(tr.id, tr);
         }
-        const trsToValidate = trsToValidateById.values().toArray();
+        const trsToValidate = [...trsToValidateById.values()];
         const { rules, use = [...qualityGateDefaultRules] } = this.config;
         const results = [];
         let fastFailed = false;
@@ -102,21 +106,21 @@ export class QualityGate {
                     previousHistory,
                     environment,
                 });
-                if (result.success) {
-                    continue;
-                }
+                const messagePayload = {
+                    actual: result.actual,
+                    expected,
+                };
                 results.push({
                     ...result,
                     expected,
                     rule: ruleId,
-                    message: rule.message({
-                        actual: result.actual,
-                        expected,
-                    }),
+                    message: result.success
+                        ? (rule.successMessage ?? defaultSuccessMessage)(messagePayload)
+                        : rule.message(messagePayload),
                     environment,
                     testResults: [...new Set([...(state?.getTestResults(ruleId) ?? []), ...result.testResults])],
                 });
-                if (ruleset.fastFail) {
+                if (!result.success && ruleset.fastFail) {
                     fastFailed = true;
                     break;
                 }

package/dist/qualityGate/rules.js

@@ -1,4 +1,4 @@
-import { filterSuccessful, filterUnsuccessful } from "@allurereport/core-api";
+import { filterIncludedInSuccessRate, filterSuccessful, filterUnsuccessful, getSuccessRate, } from "@allurereport/core-api";
 import { bold } from "yoctocolors";
 const numberStateValue = (value) => (Number.isFinite(value) ? Number(value) : 0);
 const stringArrayStateValue = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
@@ -41,12 +41,17 @@ const metricActual = (metrics, key, value) => {
         ...(sample?.unit ? { unit: sample.unit } : {}),
     };
 };
+const formatQualityGateNumber = (value) => {
+    if (!Number.isFinite(value)) {
+        return String(value);
+    }
+    return Number.isInteger(value) ? String(value) : String(Number(value.toFixed(3)));
+};
 const formatMetricValue = (value, unit) => {
     if (!Number.isFinite(value)) {
         return "n/a";
     }
-    const finiteValue = value;
-    const formatted = Number.isInteger(finiteValue) ? String(finiteValue) : String(Number(finiteValue.toFixed(3)));
+    const formatted = formatQualityGateNumber(value);
     return unit ? `${formatted} ${unit}` : formatted;
 };
 const metricRuleTitle = (actual) => actual.title ?? actual.key;
@@ -73,6 +78,7 @@ const metricDeltaWithinThreshold = (delta, threshold, better) => {
 export const maxFailuresRule = {
     rule: "maxFailures",
     message: ({ actual, expected }) => `The number of failed tests ${bold(String(actual))} exceeds the allowed threshold value ${bold(String(expected))}`,
+    successMessage: ({ actual, expected }) => `The number of failed tests ${bold(String(actual))} is within the allowed threshold value ${bold(String(expected))}`,
     validate: async ({ trs, expected, state }) => {
         const previous = numberStateValue(state.getResult());
         const failedTrs = trs.filter(filterUnsuccessful);
@@ -89,6 +95,7 @@ export const maxFailuresRule = {
 export const minTestsCountRule = {
     rule: "minTestsCount",
     message: ({ actual, expected }) => `The total number of tests ${bold(String(actual))} is less than the expected threshold value ${bold(String(expected))}`,
+    successMessage: ({ actual, expected }) => `The total number of tests ${bold(String(actual))} meets the expected threshold value ${bold(String(expected))}`,
     validate: async ({ trs, expected, state }) => {
         const actual = trs.length + numberStateValue(state.getResult());
         state.setResult(actual, []);
@@ -101,15 +108,17 @@ export const minTestsCountRule = {
 };
 export const successRateRule = {
     rule: "successRate",
-    message: ({ actual, expected }) => `Success rate ${bold(String(actual))} is less, than expected ${bold(String(expected))}`,
+    message: ({ actual, expected }) => `Success rate ${bold(formatQualityGateNumber(actual))} is less, than expected ${bold(formatQualityGateNumber(expected))}`,
+    successMessage: ({ actual, expected }) => `Success rate ${bold(formatQualityGateNumber(actual))} is not less, than expected ${bold(formatQualityGateNumber(expected))}`,
     validate: async ({ trs, expected, state }) => {
         const previous = successRateStateValue(state.getResult());
-        const passedTrs = trs.filter(filterSuccessful);
-        const notPassedTrs = trs.filter((tr) => !filterSuccessful(tr));
-        const totalCount = previous.totalCount + trs.length;
+        const eligibleTrs = trs.filter(filterIncludedInSuccessRate);
+        const passedTrs = eligibleTrs.filter(filterSuccessful);
+        const notPassedTrs = eligibleTrs.filter(filterUnsuccessful);
+        const totalCount = previous.totalCount + eligibleTrs.length;
         const passedCount = previous.passedCount + passedTrs.length;
         const testResults = notPassedTrs.map((tr) => tr.id);
-        const rate = totalCount === 0 ? 0 : passedCount / totalCount;
+        const rate = getSuccessRate({ passed: passedCount, failed: totalCount - passedCount });
         state.setResult({ totalCount, passedCount }, testResults);
         return {
             success: rate >= expected,
@@ -121,6 +130,7 @@ export const successRateRule = {
 export const maxDurationRule = {
     rule: "maxDuration",
     message: ({ actual, expected }) => `Maximum duration of some tests exceed the defined limit; actual ${bold(String(actual))}, expected ${bold(String(expected))}`,
+    successMessage: ({ actual, expected }) => `Maximum duration of the tests is within the defined limit; actual ${bold(String(actual))}, expected ${bold(String(expected))}`,
     validate: async ({ trs, expected, state }) => {
         const previous = numberStateValue(state.getResult());
         const actual = Math.max(previous, ...trs.map((tr) => tr.duration ?? 0));
@@ -137,6 +147,7 @@ export const maxDurationRule = {
 export const allTestsContainEnvRule = {
     rule: "allTestsContainEnv",
     message: ({ actual, expected }) => `Not all tests contain the required "${bold(expected)}" environment, ${bold(String(actual))} tests have different or missing environment`,
+    successMessage: ({ expected }) => `All tests contain the required "${bold(expected)}" environment`,
     validate: async ({ trs, expected, state }) => {
         const previous = numberStateValue(state.getResult());
         const testsWithoutEnv = trs.filter((tr) => (tr.environment ?? "") !== expected);
@@ -153,6 +164,7 @@ export const allTestsContainEnvRule = {
 export const environmentsTestedRule = {
     rule: "environmentsTested",
     message: ({ actual, expected }) => `The following environments were not tested: "${actual.join('", "')}"; expected all of: "${expected.join('", "')}"`,
+    successMessage: ({ expected }) => `All expected environments were tested: "${expected.join('", "')}"`,
     validate: async ({ trs, expected, state }) => {
         const previouslyTested = new Set(stringArrayStateValue(state.getResult()));
         const batchTested = trs.map((tr) => tr.environment).filter((env) => env != null && env !== "");