@allurereport/core-api 3.17.0 → 3.19.0

package/dist/categories.d.ts

@@ -82,7 +82,7 @@ export type CategoryNodeItem = {
     name: string;
     key?: string;
     value?: string;
-    historyId?: string;
+    retryHash?: string;
     retriesCount?: number;
     transition?: TestStatusTransition;
     tooltips?: Record<string, string>;

package/dist/config.d.ts

@@ -1,4 +1,9 @@
 export type DefaultLabelsConfig = Record<string, string | string[]>;
+export type FlakyDetectionConfig = {
+    historyDepth?: number;
+    includePassedTests?: boolean;
+};
+export declare const parseIntegerConfigValue: (value: unknown, minValue?: number) => number | undefined;
 export type AllureServiceConfig = {
     accessToken?: string;
     private?: boolean;
@@ -6,4 +11,4 @@ export type AllureServiceConfig = {
     uploadMaxAttempts?: number;
     uploadMaxSimultaneousFailures?: number;
 };
-export type ResolvedAllureServiceConfig = AllureServiceConfig & Required<Pick<AllureServiceConfig, "uploadConcurrency" | "uploadMaxAttempts" | "uploadMaxSimultaneousFailures">>;
+export type ResolvedAllureServiceConfig = AllureServiceConfig & Required<Pick<AllureServiceConfig, "uploadMaxAttempts" | "uploadMaxSimultaneousFailures">>;

package/dist/config.js

@@ -1 +1,7 @@
-export {};
+export const parseIntegerConfigValue = (value, minValue) => {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return undefined;
+    }
+    const normalized = Math.floor(value);
+    return minValue === undefined || normalized >= minValue ? normalized : undefined;
+};

package/dist/history.d.ts

@@ -12,7 +12,7 @@ export interface HistoryTestResult {
     duration?: number;
     labels?: TestLabel[];
     url: string;
-    historyId?: string;
+    retryHash?: string;
     reportLinks?: any[];
 }
 export interface HistoryDataPoint {
@@ -24,10 +24,12 @@ export interface HistoryDataPoint {
     metrics: Record<string, number>;
     url: string;
 }
+export type HistoryTestResultUrlResolver = (historyUrl: string, pluginId: string, historicalResultId: string) => string;
 export interface AllureHistory {
     readHistory(params?: {
         repo?: string;
         branch?: string;
     }): Promise<HistoryDataPoint[]>;
     appendHistory(history: HistoryDataPoint): Promise<void>;
+    resolveTestResultUrl?: HistoryTestResultUrlResolver;
 }

package/dist/index.d.ts

@@ -10,7 +10,7 @@ export * from "./metrics.js";
 export type * from "./model.js";
 export type * from "./testCase.js";
 export type * from "./testPlan.js";
-export type * from "./config.js";
+export * from "./config.js";
 export * from "./static.js";
 export * from "./categories.js";
 export * from "./utils/step.js";
@@ -22,8 +22,10 @@ export * from "./utils/label.js";
 export * from "./utils/parameter.js";
 export * from "./utils/testplan.js";
 export * from "./utils/status.js";
+export * from "./utils/successRate.js";
 export * from "./utils/environment.js";
 export * from "./utils/history.js";
+export * from "./utils/identity.js";
 export * from "./utils/strings.js";
 export * from "./utils/dictionary.js";
 export * from "./utils/path.js";

package/dist/index.js

@@ -2,6 +2,7 @@ export * from "./constants.js";
 export * from "./ci.js";
 export * from "./gitFlow.js";
 export * from "./metrics.js";
+export * from "./config.js";
 export * from "./static.js";
 export * from "./categories.js";
 export * from "./utils/step.js";
@@ -12,8 +13,10 @@ export * from "./utils/label.js";
 export * from "./utils/parameter.js";
 export * from "./utils/testplan.js";
 export * from "./utils/status.js";
+export * from "./utils/successRate.js";
 export * from "./utils/environment.js";
 export * from "./utils/history.js";
+export * from "./utils/identity.js";
 export * from "./utils/strings.js";
 export * from "./utils/dictionary.js";
 export * from "./utils/path.js";

package/dist/model.d.ts

@@ -21,6 +21,9 @@ export interface SourceMetadata {
     metadata: {
         [key: string]: any;
     };
+    legacyHistoryId?: string;
+    reportedFlaky?: boolean;
+    legacyTestCaseHash?: string;
 }
 export interface TestError {
     message?: string;
@@ -33,10 +36,13 @@ export interface TestResult {
     name: string;
     status: TestStatus;
     error?: TestError;
+    errors?: TestError[];
     testCase?: TestCase;
     environment?: string;
     fullName?: string;
-    historyId?: string;
+    testCaseHash: string | null;
+    parametersHash: string;
+    environmentHash: string | null;
     description?: string;
     descriptionHtml?: string;
     precondition?: string;
@@ -48,10 +54,11 @@ export interface TestResult {
     duration?: number;
     flaky: boolean;
     muted: boolean;
+    known: boolean;
     resolution?: ResolutionCategory;
     resolutionComment?: string;
     transition?: TestStatusTransition;
-    retryHash?: string;
+    retryHash: string | null;
     isRetry: boolean;
     hostId?: string;
     threadId?: string;

package/dist/utils/history.d.ts

@@ -1,10 +1,9 @@
 import type { HistoryDataPoint, HistoryTestResult } from "../history.js";
-import type { TestParameter } from "../metadata.js";
 import type { TestResult } from "../model.js";
-export declare const stringifyHistoryParams: (parameters?: TestParameter[]) => string;
-export declare const getFallbackHistoryId: (tr: Pick<TestResult, "labels" | "parameters">) => string | undefined;
-export declare const getHistoryIdCandidates: (tr: Pick<TestResult, "historyId" | "labels" | "parameters">) => string[];
+export declare const createHistoryTestResultLookup: (testResults: Iterable<TestResult | HistoryTestResult>) => <T extends TestResult | HistoryTestResult>(point: {
+    testResults?: Record<string, T>;
+}, result: TestResult | HistoryTestResult) => T | undefined;
 export declare const normalizeHistoryDataPoint: (historyDataPoint: HistoryDataPoint) => HistoryDataPoint;
 export declare const normalizeHistoryDataPointUrls: (historyDataPoint: HistoryDataPoint) => HistoryDataPoint;
-export declare const selectHistoryTestResults: (historyDataPoints: HistoryDataPoint[], historyIdCandidates: readonly string[]) => HistoryTestResult[];
+export declare const selectHistoryTestResults: (historyDataPoints: HistoryDataPoint[], retryHashes: readonly string[]) => HistoryTestResult[];
 export declare const htrsByTr: (hdps: HistoryDataPoint[], tr: TestResult | HistoryTestResult) => HistoryTestResult[];

package/dist/utils/history.js

@@ -1,13 +1,25 @@
-import { createHash } from "node:crypto";
-import { fallbackTestCaseIdLabelName } from "../constants.js";
-import { findLastByLabelName } from "./label.js";
-const md5 = (data) => createHash("md5").update(data).digest("hex");
+import { DEFAULT_ENVIRONMENT } from "./environment.js";
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const normalizeHistoryTestResults = (testResults) => {
     if (!isRecord(testResults)) {
         return {};
     }
-    return Object.fromEntries(Object.entries(testResults).filter(([, value]) => isRecord(value)));
+    return Object.fromEntries(Object.entries(testResults).flatMap(([retryHash, value]) => {
+        if (!isRecord(value)) {
+            return [];
+        }
+        const historyTestResult = { ...value };
+        delete historyTestResult.historyId;
+        return [
+            [
+                retryHash,
+                {
+                    ...historyTestResult,
+                    retryHash,
+                },
+            ],
+        ];
+    }));
 };
 const normalizeHistoryMetrics = (metrics) => {
     if (!isRecord(metrics)) {
@@ -15,33 +27,64 @@ const normalizeHistoryMetrics = (metrics) => {
     }
     return Object.fromEntries(Object.entries(metrics).filter(([, value]) => Number.isFinite(value)));
 };
-const parametersCompare = (a, b) => {
-    return (a.name ?? "").localeCompare(b.name ?? "") || (a.value ?? "").localeCompare(b.value ?? "");
-};
-export const stringifyHistoryParams = (parameters = []) => {
-    return [...parameters]
-        .filter((parameter) => !parameter?.excluded)
-        .sort(parametersCompare)
-        .map((parameter) => `${parameter.name}:${parameter.value}`)
-        .join(",");
-};
-export const getFallbackHistoryId = (tr) => {
-    const fallbackTestCaseId = findLastByLabelName(tr.labels ?? [], fallbackTestCaseIdLabelName);
-    if (!fallbackTestCaseId) {
-        return undefined;
+const isDefaultEnvironment = (result) => result.environment === undefined || result.environment === DEFAULT_ENVIRONMENT;
+export const createHistoryTestResultLookup = (testResults) => {
+    const canonicalKeys = new Set();
+    const retryHashByLegacyHistoryId = new Map();
+    for (const result of testResults) {
+        if (!result.retryHash) {
+            continue;
+        }
+        canonicalKeys.add(result.retryHash);
+        const legacyId = "sourceMetadata" in result ? result.sourceMetadata?.legacyHistoryId : undefined;
+        if (!legacyId || !isDefaultEnvironment(result) || ("environmentHash" in result && result.environmentHash)) {
+            continue;
+        }
+        if (!retryHashByLegacyHistoryId.has(legacyId)) {
+            retryHashByLegacyHistoryId.set(legacyId, result.retryHash);
+        }
+        else if (retryHashByLegacyHistoryId.get(legacyId) !== result.retryHash) {
+            retryHashByLegacyHistoryId.set(legacyId, undefined);
+        }
     }
-    return `${fallbackTestCaseId}.${md5(stringifyHistoryParams(tr.parameters ?? []))}`;
-};
-export const getHistoryIdCandidates = (tr) => {
-    const result = [];
-    if (tr.historyId) {
-        result.push(tr.historyId);
+    for (const [legacyId, retryHash] of retryHashByLegacyHistoryId) {
+        if (retryHash === undefined || (canonicalKeys.has(legacyId) && legacyId !== retryHash)) {
+            retryHashByLegacyHistoryId.set(legacyId, undefined);
+        }
     }
-    const fallbackHistoryId = getFallbackHistoryId(tr);
-    if (fallbackHistoryId && !result.includes(fallbackHistoryId)) {
-        result.push(fallbackHistoryId);
+    const legacyByCanonical = new Map();
+    for (const [legacyId, retryHash] of retryHashByLegacyHistoryId) {
+        if (!retryHash || legacyId === retryHash) {
+            continue;
+        }
+        legacyByCanonical.set(retryHash, legacyByCanonical.has(retryHash) ? undefined : legacyId);
     }
-    return result;
+    return (point, result) => {
+        if (!result.retryHash) {
+            return undefined;
+        }
+        const historicalDefault = !("sourceMetadata" in result) && isDefaultEnvironment(result);
+        const retryHash = historicalDefault
+            ? (retryHashByLegacyHistoryId.get(result.retryHash) ?? result.retryHash)
+            : result.retryHash;
+        const canonical = Object.hasOwn(point.testResults ?? {}, retryHash) ? point.testResults?.[retryHash] : undefined;
+        if (canonical) {
+            return canonical;
+        }
+        const legacyId = "sourceMetadata" in result
+            ? result.sourceMetadata?.legacyHistoryId
+            : historicalDefault
+                ? legacyByCanonical.get(retryHash)
+                : undefined;
+        if (!legacyId ||
+            retryHashByLegacyHistoryId.get(legacyId) !== retryHash ||
+            !isDefaultEnvironment(result) ||
+            ("environmentHash" in result && result.environmentHash)) {
+            return undefined;
+        }
+        const legacy = Object.hasOwn(point.testResults ?? {}, legacyId) ? point.testResults?.[legacyId] : undefined;
+        return legacy && isDefaultEnvironment(legacy) ? legacy : undefined;
+    };
 };
 export const normalizeHistoryDataPoint = (historyDataPoint) => ({
     ...historyDataPoint,
@@ -57,14 +100,14 @@ export const normalizeHistoryDataPointUrls = (historyDataPoint) => {
         return normalizedHistoryDataPoint;
     }
     let testResults = normalizedHistoryDataPoint.testResults;
-    for (const [historyId, historyTestResult] of Object.entries(normalizedHistoryDataPoint.testResults)) {
+    for (const [retryHash, historyTestResult] of Object.entries(normalizedHistoryDataPoint.testResults)) {
         if (historyTestResult.url) {
             continue;
         }
         if (testResults === normalizedHistoryDataPoint.testResults) {
             testResults = { ...normalizedHistoryDataPoint.testResults };
         }
-        testResults[historyId] = {
+        testResults[retryHash] = {
             ...historyTestResult,
             url,
         };
@@ -77,13 +120,13 @@ export const normalizeHistoryDataPointUrls = (historyDataPoint) => {
         testResults,
     };
 };
-export const selectHistoryTestResults = (historyDataPoints, historyIdCandidates) => {
-    if (historyIdCandidates.length === 0) {
+export const selectHistoryTestResults = (historyDataPoints, retryHashes) => {
+    if (retryHashes.length === 0) {
         return [];
     }
     return historyDataPoints.reduce((acc, historyDataPoint) => {
-        for (const historyId of historyIdCandidates) {
-            const historyTestResult = historyDataPoint.testResults?.[historyId];
+        for (const retryHash of retryHashes) {
+            const historyTestResult = historyDataPoint.testResults?.[retryHash];
             if (!historyTestResult) {
                 continue;
             }
@@ -94,8 +137,9 @@ export const selectHistoryTestResults = (historyDataPoints, historyIdCandidates)
     }, []);
 };
 export const htrsByTr = (hdps, tr) => {
-    if (!tr?.historyId) {
-        return [];
-    }
-    return selectHistoryTestResults(hdps, [tr.historyId]);
+    const lookup = createHistoryTestResultLookup([tr]);
+    return hdps.flatMap((point) => {
+        const result = lookup(point, tr);
+        return result ? [result] : [];
+    });
 };

package/dist/utils/identity.d.ts

@@ -0,0 +1,17 @@
+export declare const UNKNOWN_PARAMETER_VALUE = "#___unknown_value___#";
+export type IdentityParameter = {
+    name?: string | null;
+    value?: string | null;
+    excluded?: boolean | null;
+};
+export declare const compareUtf8: (first: string, second: string) => number;
+export declare const md5Utf8: (value: string) => string;
+export declare const calculateTestCaseHash: (testCaseId: string | null | undefined, fullName: string | null | undefined) => string | null;
+export declare const stringifyIdentityParameters: (parameters: readonly (IdentityParameter | null | undefined)[] | null | undefined) => string;
+export declare const calculateParametersHash: (parameters: readonly (IdentityParameter | null | undefined)[] | null | undefined) => string;
+export declare const calculateEnvironmentHash: (namedEnvironmentId: string | null | undefined) => string | null;
+export declare const calculateRetryHash: ({ testCaseHash, parametersHash, environmentHash, }: {
+    testCaseHash: string | null | undefined;
+    parametersHash: string;
+    environmentHash?: string | null;
+}) => string | null;

package/dist/utils/identity.js

@@ -0,0 +1,50 @@
+import { createHash } from "node:crypto";
+import { DEFAULT_ENVIRONMENT } from "./environment.js";
+export const UNKNOWN_PARAMETER_VALUE = "#___unknown_value___#";
+const utf8Encoder = new TextEncoder();
+export const compareUtf8 = (first, second) => {
+    const firstBytes = utf8Encoder.encode(first);
+    const secondBytes = utf8Encoder.encode(second);
+    const length = Math.min(firstBytes.length, secondBytes.length);
+    for (let index = 0; index < length; index++) {
+        const comparison = firstBytes[index] - secondBytes[index];
+        if (comparison !== 0) {
+            return comparison;
+        }
+    }
+    return firstBytes.length - secondBytes.length;
+};
+export const md5Utf8 = (value) => createHash("md5").update(value, "utf8").digest("hex");
+export const calculateTestCaseHash = (testCaseId, fullName) => {
+    const identity = testCaseId?.length ? testCaseId : fullName?.length ? fullName : undefined;
+    return identity === undefined ? null : md5Utf8(identity);
+};
+const compareIdentityParameters = (first, second) => compareUtf8(first.name, second.name) || compareUtf8(first.value, second.value);
+export const stringifyIdentityParameters = (parameters) => {
+    const normalized = [];
+    for (const parameter of parameters ?? []) {
+        if (parameter == null) {
+            continue;
+        }
+        const { name } = parameter;
+        if (typeof name !== "string" || name.length === 0 || parameter.excluded === true) {
+            continue;
+        }
+        normalized.push({
+            name,
+            value: parameter.value ?? UNKNOWN_PARAMETER_VALUE,
+        });
+    }
+    const unique = normalized
+        .sort(compareIdentityParameters)
+        .filter((parameter, index, all) => index === 0 || parameter.name !== all[index - 1].name || parameter.value !== all[index - 1].value);
+    return unique.map(({ name, value }) => `${name}:${value}`).join(",");
+};
+export const calculateParametersHash = (parameters) => md5Utf8(stringifyIdentityParameters(parameters));
+export const calculateEnvironmentHash = (namedEnvironmentId) => namedEnvironmentId == null || namedEnvironmentId === DEFAULT_ENVIRONMENT ? null : md5Utf8(namedEnvironmentId);
+export const calculateRetryHash = ({ testCaseHash, parametersHash, environmentHash, }) => {
+    if (!testCaseHash) {
+        return null;
+    }
+    return environmentHash ? `${testCaseHash}.${parametersHash}.${environmentHash}` : `${testCaseHash}.${parametersHash}`;
+};

package/dist/utils/successRate.d.ts

@@ -0,0 +1,3 @@
+import type { Statistic } from "../aggregate.js";
+export declare const getSuccessRateTotal: (statistic: Partial<Statistic>) => number;
+export declare const getSuccessRate: (statistic: Partial<Statistic>) => number;

package/dist/utils/successRate.js

@@ -0,0 +1,6 @@
+import { includedInSuccessRate } from "../constants.js";
+export const getSuccessRateTotal = (statistic) => Array.from(includedInSuccessRate).reduce((total, status) => total + (statistic[status] ?? 0), 0);
+export const getSuccessRate = (statistic) => {
+    const total = getSuccessRateTotal(statistic);
+    return total > 0 ? (statistic.passed ?? 0) / total : 0;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/core-api",
-  "version": "3.17.0",
+  "version": "3.19.0",
   "description": "Allure Core API",
   "keywords": [
     "allure"