@allurereport/plugin-api 3.16.0 → 3.17.0

package/dist/config.d.ts

@@ -1,4 +1,4 @@
-import type { AllureServiceConfig, CategoriesConfig, DefaultLabelsConfig, EnvironmentsConfig, KnownIssuesPathConfig, ReportVariables, KnownIssuesConfig } from "@allurereport/core-api";
+import type { AllureServiceConfig, CategoriesConfig, DefaultLabelsConfig, EnvironmentsConfig, PerformanceConfig, ReportVariables, ResolutionsConfig } from "@allurereport/core-api";
 import type { PluginDescriptor } from "./plugin.js";
 import type { QualityGateConfig } from "./qualityGate.js";
 export interface Config {
@@ -9,8 +9,7 @@ export interface Config {
     hideLabels?: (string | RegExp)[];
     historyPath?: string;
     historyLimit?: number;
-    knownIssuesPath?: KnownIssuesPathConfig;
-    knownIssues?: KnownIssuesConfig;
+    resolutions?: ResolutionsConfig;
     defaultLabels?: DefaultLabelsConfig;
     dump?: string;
     environment?: string;
@@ -20,6 +19,7 @@ export interface Config {
     plugins?: Record<string, PluginDescriptor>;
     appendHistory?: boolean;
     qualityGate?: QualityGateConfig;
+    performance?: PerformanceConfig;
     allureService?: AllureServiceConfig;
     categories?: CategoriesConfig;
     globalAttachments?: string[];

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./config.js";
 export type * from "./plugin.js";
 export type * from "./qualityGate.js";
+export type * from "./report.js";
 export * from "./store.js";
 export type * from "./resultFile.js";
 export * from "./utils/misc.js";

package/dist/plugin.d.ts

@@ -34,7 +34,7 @@ export interface PluginContext {
     categories?: CategoryDefinition[];
     history?: AllureHistory;
 }
-export type TestResultSummary = Pick<TestResult, "id" | "name" | "duration" | "status">;
+export type TestResultSummary = Pick<TestResult, "id" | "name" | "duration" | "environment" | "status">;
 export interface TestResultRegistry {
     byId: Record<string, TestResultSummary>;
 }

package/dist/qualityGate.d.ts

@@ -1,4 +1,4 @@
-import type { KnownTestFailure, TestResult } from "@allurereport/core-api";
+import type { MetricSample, TestResult } from "@allurereport/core-api";
 export type QualityGateValidationResult = {
     success: boolean;
     expected: any;
@@ -13,28 +13,34 @@ export type QualityGateRules = Record<string, any> & {
     fastFail?: boolean;
     filter?: (tr: TestResult) => boolean;
 };
-export type QualityGateRuleResult = {
+export type QualityGateRuleResult<T = unknown> = {
     success: boolean;
-    actual: any;
+    actual: T;
     testResults: string[];
 };
-export interface QualityGateRuleState<T> {
-    getResult(): T | undefined;
-    setResult(value: T, testResults: QualityGateRuleResult["testResults"]): void;
+export interface QualityGateRuleState {
+    getResult(): unknown;
+    setResult(value: unknown, testResults: string[]): void;
 }
-export type QualityGateRule<T = any, K = T> = {
+export type QualityGateMetricHistoryPoint = {
+    uuid?: string;
+    timestamp?: number;
+    metrics?: Record<string, number>;
+};
+export type QualityGateRule<T = unknown, K = T> = {
     rule: string;
     message: (payload: {
         expected: T;
-        actual: T;
+        actual: K;
     }) => string;
     validate: (payload: {
         expected: T;
         trs: TestResult[];
-        knownIssues: KnownTestFailure[];
-        state: QualityGateRuleState<K>;
+        state: QualityGateRuleState;
+        metrics?: MetricSample[];
+        previousHistory?: QualityGateMetricHistoryPoint[];
         environment?: string;
-    }) => Promise<QualityGateRuleResult>;
+    }) => Promise<QualityGateRuleResult<K>>;
 };
 export type QualityGateConfig = {
     rules?: QualityGateRules[];

package/dist/report.d.ts

@@ -0,0 +1,139 @@
+import type { AttachmentTestStepResult, CiDescriptor, DefaultTreeGroup, HistoryTestResult, ResolutionCategory, ResolutionIssue, TestFixtureResult, TestResult, TestStatus, TestStepResult, TreeData, WithChildren } from "@allurereport/core-api";
+import type { QualityGateValidationResult } from "./qualityGate.js";
+export type Layout = "base" | "split";
+export type StepTreeExpansion = "collapsed" | "expand_failed_only" | "expanded";
+export type ReportRunSummary = {
+    start: number;
+    stop: number;
+    duration: number;
+};
+export type ReportExecutorInfo = {
+    name?: string;
+    type?: string;
+    url?: string;
+    buildOrder?: number;
+    buildName?: string;
+    buildUrl?: string;
+    reportName?: string;
+    reportUrl?: string;
+};
+export type ReportOptions = {
+    id?: string;
+    allureVersion: string;
+    reportName?: string;
+    logo?: string;
+    theme?: "light" | "dark" | "auto";
+    groupBy?: string[];
+    reportLanguage?: string;
+    createdAt: number;
+    reportUuid: string;
+    layout?: Layout;
+    defaultSection?: string;
+    sections?: string[];
+    cacheKey?: string;
+    ci?: CiDescriptor;
+    executor?: ReportExecutorInfo;
+    runSummary?: ReportRunSummary;
+    stepTreeExpansion?: StepTreeExpansion;
+    defaultSortBy?: string;
+};
+export type ReportFixtureResult = Omit<TestFixtureResult, "testResultIds" | "start" | "stop" | "sourceMetadata" | "steps"> & {
+    steps: ReportTestStepResult[];
+};
+export type ReportStatus = TestStatus | "total";
+export type ReportTestStepResult = TestStepResult;
+type ReportBreadcrumbItem = string[] | string[][];
+export interface ReportCategory {
+    id?: string;
+    name: string;
+    grouping?: {
+        key: string;
+        value?: string;
+        name?: string;
+    }[];
+    description?: string;
+    descriptionHtml?: string;
+    messageRegex?: string;
+    traceRegex?: string;
+    matchedStatuses?: TestStatus[];
+    flaky?: boolean;
+}
+export type ReportTestResult = Omit<TestResult, "runSelector" | "sourceMetadata" | "expectedResult" | "expectedResultHtml" | "precondition" | "preconditionHtml" | "steps" | "categories" | "environment"> & {
+    isRetry: boolean;
+    setup: ReportFixtureResult[];
+    teardown: ReportFixtureResult[];
+    steps: ReportTestStepResult[];
+    history: HistoryTestResult[];
+    retries?: TestResult[];
+    retriesCount?: number;
+    groupedLabels: Record<string, string[]>;
+    attachments?: AttachmentTestStepResult[];
+    breadcrumbs: ReportBreadcrumbItem[];
+    order?: number;
+    groupOrder?: number;
+    retry: boolean;
+    categories?: ReportCategory[];
+    environment?: string | "default";
+    resolutionIssue?: ResolutionIssue;
+    tooltips?: Record<string, string>;
+    time?: Record<string, string[]>;
+    extra?: {
+        severity: string;
+    };
+};
+export type ReportTreeLeaf = Pick<ReportTestResult, "duration" | "name" | "start" | "status" | "groupOrder" | "flaky" | "transition" | "retry" | "retriesCount" | "resolution"> & {
+    nodeId: string;
+    id?: string;
+    transitionTooltip?: string;
+    tooltips?: Record<string, string>;
+    tags?: string[];
+    categories?: string[];
+};
+export type ReportTreeGroup = WithChildren & DefaultTreeGroup & {
+    nodeId: string;
+};
+export type ReportTree = TreeData<ReportTreeLeaf, ReportTreeGroup>;
+export type ReportQualityGateValidationResult = QualityGateValidationResult & {
+    testResultsTree?: ReportTree;
+};
+export type ReportQualityGateResults = Record<string, ReportQualityGateValidationResult[]>;
+export type ReportSearchDocument = {
+    id: string;
+    nodeId: string;
+    name: string;
+    fullName?: string;
+    historyId?: string;
+    labels?: string;
+    owner?: string;
+    tags?: string;
+    parameters?: string;
+    categories?: string;
+    statusMessage?: string;
+    links?: string;
+};
+export type ReportResolutionTestResult = Pick<ReportTreeLeaf, "nodeId" | "id" | "name" | "status" | "duration" | "flaky" | "transition" | "retry" | "retriesCount" | "resolution" | "tooltips"> & {
+    groupOrder?: number;
+};
+export type ReportResolutionGroup = {
+    id: string;
+    resolution: ResolutionCategory;
+    name: string;
+    comment?: string;
+    issue?: ResolutionIssue;
+    testResults: ReportResolutionTestResult[];
+};
+export type ReportResolutionCategories = {
+    groups: ReportResolutionGroup[];
+};
+export type ReportRecursiveTree = DefaultTreeGroup & {
+    nodeId: string;
+    leaves: ReportTreeLeaf[];
+    trees: ReportRecursiveTree[];
+    duration?: number;
+    groupOrder?: number;
+    minStart?: number;
+};
+export type ReportTestResultGroup = Pick<ReportTestResult, "name" | "fullName" | "groupOrder"> & {
+    testResults: ReportTestResult[];
+};
+export {};

package/dist/report.js

@@ -0,0 +1 @@
+export {};

package/dist/staticAssets.d.ts

@@ -0,0 +1,9 @@
+import type { ReportFiles } from "./plugin.js";
+export type ReportStaticManifest = Record<string, string>;
+export type ReportStaticAssets = {
+    manifest: ReportStaticManifest;
+    files: ReadonlyMap<string, Buffer>;
+};
+export declare const readReportStaticAssets: (archive: string | URL) => Promise<ReportStaticAssets>;
+export declare const getReportStaticAsset: (assets: ReportStaticAssets, fileName: string) => Buffer;
+export declare const copyReportStaticAssets: (assets: ReportStaticAssets, reportFiles: ReportFiles) => Promise<void>;

package/dist/staticAssets.js

@@ -0,0 +1,105 @@
+import { createReadStream } from "node:fs";
+import { posix } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { extract } from "tar-stream";
+const validateEntryName = (name) => {
+    if (!name ||
+        name.includes("\0") ||
+        name.includes("\\") ||
+        posix.isAbsolute(name) ||
+        posix.normalize(name) !== name ||
+        name === ".." ||
+        name.startsWith("../")) {
+        throw new Error(`Unsafe report static archive entry: ${JSON.stringify(name)}`);
+    }
+};
+const parseManifest = (content) => {
+    let manifest;
+    try {
+        manifest = JSON.parse(content.toString("utf8"));
+    }
+    catch (error) {
+        throw new Error("The report static archive contains an invalid manifest.json", { cause: error });
+    }
+    if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
+        throw new Error("The report static archive manifest must be an object");
+    }
+    for (const [key, value] of Object.entries(manifest)) {
+        if (!key || typeof value !== "string") {
+            throw new Error("The report static archive manifest must map non-empty keys to file names");
+        }
+        validateEntryName(value);
+    }
+    return manifest;
+};
+export const readReportStaticAssets = async (archive) => {
+    const files = new Map();
+    const archiveExtractor = extract();
+    let archiveError;
+    archiveExtractor.on("entry", (header, stream, next) => {
+        const skipEntry = (error) => {
+            archiveError ?? (archiveError = error);
+            stream.on("end", next);
+            stream.resume();
+        };
+        if (header.type === "directory") {
+            stream.on("end", next);
+            stream.resume();
+            return;
+        }
+        if (header.type !== "file") {
+            skipEntry(new Error(`Unsupported report static archive entry type: ${header.type}`));
+            return;
+        }
+        try {
+            validateEntryName(header.name);
+            if (files.has(header.name)) {
+                throw new Error(`Duplicate report static archive entry: ${header.name}`);
+            }
+        }
+        catch (error) {
+            skipEntry(error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        const chunks = [];
+        stream.on("data", (chunk) => {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        stream.on("error", (error) => archiveExtractor.destroy(error));
+        stream.on("end", () => {
+            files.set(header.name, Buffer.concat(chunks));
+            next();
+        });
+    });
+    await pipeline(createReadStream(archive), archiveExtractor);
+    if (archiveError) {
+        throw archiveError;
+    }
+    const manifestContent = files.get("manifest.json");
+    if (!manifestContent) {
+        throw new Error("The report static archive does not contain manifest.json");
+    }
+    files.delete("manifest.json");
+    const manifest = parseManifest(manifestContent);
+    if (!manifest["main.js"]) {
+        throw new Error('The report static archive manifest does not contain "main.js"');
+    }
+    for (const fileName of Object.values(manifest)) {
+        if (!files.has(fileName)) {
+            throw new Error(`The report static archive does not contain manifest asset: ${fileName}`);
+        }
+    }
+    return { manifest, files };
+};
+export const getReportStaticAsset = (assets, fileName) => {
+    const content = assets.files.get(fileName);
+    if (!content) {
+        throw new Error(`The report static archive does not contain asset: ${fileName}`);
+    }
+    return content;
+};
+export const copyReportStaticAssets = async (assets, reportFiles) => {
+    for (const [fileName, content] of assets.files) {
+        await reportFiles.addFile(fileName, content);
+    }
+};

package/dist/store.d.ts

@@ -1,4 +1,4 @@
-import type { AllureCheckResult, AttachmentLink, EnvironmentIdentity, GlobalAttachmentLink, HistoryDataPoint, HistoryTestResult, KnownTestFailure, ReportVariables, Statistic, TestCase, TestEnvGroup, TestError, TestFixtureResult, TestResult } from "@allurereport/core-api";
+import type { AllureCheckResult, AttachmentLink, EnvironmentIdentity, GlobalAttachmentLink, HistoryDataPoint, HistoryTestResult, ResolutionIssue, MetricSample, ReportVariables, Statistic, TestCase, TestEnvGroup, TestError, TestFixtureResult, TestResult } from "@allurereport/core-api";
 import type { ExitCode, PluginGlobalError } from "./plugin.js";
 import type { QualityGateValidationResult } from "./qualityGate.js";
 import type { ResultFile } from "./resultFile.js";
@@ -21,7 +21,10 @@ export interface AllureStore {
     allHistoryDataPoints: () => Promise<HistoryDataPoint[]>;
     allHistoryDataPointsByEnvironment: (environment: string) => Promise<HistoryDataPoint[]>;
     allHistoryDataPointsByEnvironmentId: (environmentId: string) => Promise<HistoryDataPoint[]>;
-    allKnownIssues: () => Promise<KnownTestFailure[]>;
+    allResolutionIssues: () => Promise<ResolutionIssue[]>;
+    resolutionIssueByTestResultId: (trId: string) => Promise<ResolutionIssue | undefined>;
+    testResultsByResolutionIssueId: (resolutionIssueId: string) => Promise<TestResult[]>;
+    allMetrics: () => Promise<MetricSample[]>;
     allNewTestResults: (filter?: TestResultFilter, history?: HistoryDataPoint[]) => Promise<TestResult[]>;
     addCheckResult: (result: AllureCheckResult) => Promise<void>;
     allCheckResults: () => Promise<AllureCheckResult[]>;
@@ -77,11 +80,13 @@ export interface AllureStoreDump {
     fixtures: Record<string, TestFixtureResult>;
     environments: Array<string | EnvironmentIdentity>;
     reportVariables: ReportVariables;
-    knownIssues: Record<string, KnownTestFailure>;
+    resolutionIssues: Record<string, ResolutionIssue>;
     qualityGateResults: QualityGateValidationResult[];
+    metrics?: MetricSample[];
     indexAttachmentByTestResult: Record<string, string[]>;
     indexTestResultByHistoryId: Record<string, string[]>;
     indexTestResultByTestCase: Record<string, string[]>;
+    indexTestResultByResolutionIssue: Record<string, string[]>;
     indexAttachmentByFixture: Record<string, string[]>;
     indexFixturesByTestResult: Record<string, string[]>;
     testResultIdsIngestOrder: string[];
@@ -96,12 +101,14 @@ export declare enum AllureStoreDumpFiles {
     CheckResults = "check-results.json",
     Environments = "environments.json",
     ReportVariables = "report-variables.json",
-    KnownIssues = "known-issues.json",
+    ResolutionIssues = "resolution-issues.json",
     IndexAttachmentsByTestResults = "index-attachments-by-test-results.json",
     IndexTestResultsByHistoryId = "index-test-results-by-history-id.json",
     IndexTestResultsByTestCase = "index-test-results-by-test-case.json",
+    IndexTestResultsByResolutionIssue = "index-test-results-by-resolution-issue.json",
     IndexAttachmentsByFixture = "index-attachments-by-fixture.json",
     IndexFixturesByTestResult = "index-fixtures-by-test-result.json",
     QualityGateResults = "quality-gate-results.json",
-    TestResultIngestOrder = "test-result-ingest-order.json"
+    TestResultIngestOrder = "test-result-ingest-order.json",
+    Metrics = "metrics.json"
 }

package/dist/store.js

@@ -9,12 +9,14 @@ export var AllureStoreDumpFiles;
     AllureStoreDumpFiles["CheckResults"] = "check-results.json";
     AllureStoreDumpFiles["Environments"] = "environments.json";
     AllureStoreDumpFiles["ReportVariables"] = "report-variables.json";
-    AllureStoreDumpFiles["KnownIssues"] = "known-issues.json";
+    AllureStoreDumpFiles["ResolutionIssues"] = "resolution-issues.json";
     AllureStoreDumpFiles["IndexAttachmentsByTestResults"] = "index-attachments-by-test-results.json";
     AllureStoreDumpFiles["IndexTestResultsByHistoryId"] = "index-test-results-by-history-id.json";
     AllureStoreDumpFiles["IndexTestResultsByTestCase"] = "index-test-results-by-test-case.json";
+    AllureStoreDumpFiles["IndexTestResultsByResolutionIssue"] = "index-test-results-by-resolution-issue.json";
     AllureStoreDumpFiles["IndexAttachmentsByFixture"] = "index-attachments-by-fixture.json";
     AllureStoreDumpFiles["IndexFixturesByTestResult"] = "index-fixtures-by-test-result.json";
     AllureStoreDumpFiles["QualityGateResults"] = "quality-gate-results.json";
     AllureStoreDumpFiles["TestResultIngestOrder"] = "test-result-ingest-order.json";
+    AllureStoreDumpFiles["Metrics"] = "metrics.json";
 })(AllureStoreDumpFiles || (AllureStoreDumpFiles = {}));

package/dist/utils/summary.js

@@ -4,6 +4,7 @@ export const convertToTestResultSummary = (tr) => ({
     name: tr.name,
     duration: tr.duration,
     status: tr.status,
+    ...(tr.environment ? { environment: tr.environment } : {}),
 });
 export const createTestResultRegistry = (testResults) => ({
     byId: Object.fromEntries(testResults.map((testResult) => [testResult.id, convertToTestResultSummary(testResult)])),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-api",
-  "version": "3.16.0",
+  "version": "3.17.0",
   "description": "Allure Plugin API",
   "keywords": [
     "allure"
@@ -9,14 +9,17 @@
   "author": "Qameta Software",
   "repository": "https://github.com/allure-framework/allure3",
   "files": [
-    "dist"
+    "dist",
+    "!dist/packStaticAssets.d.ts",
+    "!dist/packStaticAssets.js"
   ],
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js"
+    ".": "./dist/index.js",
+    "./static-assets": "./dist/staticAssets.js"
   },
   "scripts": {
     "build": "run clean && tsc --project ./tsconfig.json",
@@ -26,10 +29,12 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.16.0"
+    "@allurereport/core-api": "3.17.0",
+    "tar-stream": "3.1.7"
   },
   "devDependencies": {
     "@types/node": "^20",
+    "@types/tar-stream": "^3.1.4",
     "@vitest/runner": "^2",
     "@vitest/snapshot": "^2.1.9",
     "allure-js-commons": "^3",