@allurereport/plugin-api 3.0.0-beta.8 → 3.0.0

package/dist/config.d.ts

@@ -1,13 +1,25 @@
+import type { DefaultLabelsConfig, EnvironmentsConfig, ReportVariables } from "@allurereport/core-api";
 import type { PluginDescriptor } from "./plugin.js";
 import type { QualityGateConfig } from "./qualityGate.js";
-export type DefaultLabelsConfig = Record<string, string | string[]>;
 export interface Config {
     name?: string;
     output?: string;
+    open?: boolean;
+    port?: string;
     historyPath?: string;
     knownIssuesPath?: string;
-    qualityGate?: QualityGateConfig;
-    plugins?: Record<string, PluginDescriptor>;
     defaultLabels?: DefaultLabelsConfig;
+    stage?: string;
+    environment?: string;
+    environments?: EnvironmentsConfig;
+    variables?: ReportVariables;
+    plugins?: Record<string, PluginDescriptor>;
+    appendHistory?: boolean;
+    qualityGate?: QualityGateConfig;
+    allureService?: {
+        url?: string;
+        project?: string;
+        accessToken?: string;
+    };
 }
 export declare const defineConfig: (allureConfig: Config) => Config;

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,3 +1,5 @@
 export * from "./config.js";
+export * from "./store.js";
 export * from "./utils/misc.js";
 export * from "./utils/tree.js";
+export * from "./utils/summary.js";

package/dist/plugin.d.ts

@@ -1,3 +1,6 @@
+import type { AttachmentLink, CiDescriptor, Statistic, TestError, TestResult, TestStatus } from "@allurereport/core-api";
+import type { QualityGateValidationResult } from "./qualityGate.js";
+import type { ResultFile } from "./resultFile.js";
 import type { AllureStore } from "./store.js";
 export interface PluginDescriptor {
     import?: string;
@@ -5,30 +8,74 @@ export interface PluginDescriptor {
     options?: Record<string, any>;
 }
 export interface ReportFiles {
-    addFile(path: string, data: Buffer): Promise<void>;
+    addFile(path: string, data: Buffer): Promise<string>;
 }
 export interface PluginState {
     set(key: string, value: any): Promise<void>;
-    get(key: string): Promise<void>;
+    get<T>(key: string): Promise<T>;
     unset(key: string): Promise<void>;
 }
 export interface PluginContext {
+    id: string;
+    publish: boolean;
     state: PluginState;
     allureVersion: string;
     reportUuid: string;
     reportName: string;
     reportFiles: ReportFiles;
+    reportUrl?: string;
+    ci?: CiDescriptor;
+}
+export type SummaryTestResult = Pick<TestResult, "name" | "id" | "status" | "duration">;
+export interface PluginSummary {
+    href?: string;
+    remoteHref?: string;
+    jobHref?: string;
+    pullRequestHref?: string;
+    name: string;
+    stats: Statistic;
+    status: TestStatus;
+    duration: number;
+    plugin?: string;
+    newTests?: SummaryTestResult[];
+    flakyTests?: SummaryTestResult[];
+    retryTests?: SummaryTestResult[];
+    createdAt?: number;
+    meta?: Record<string, any>;
+}
+export interface ExitCode {
+    actual?: number;
+    original: number;
+}
+export interface PluginGlobals {
+    exitCode?: ExitCode;
+    errors: TestError[];
+    attachments: AttachmentLink[];
 }
 export interface BatchOptions {
     maxTimeout?: number;
 }
-export interface Realtime {
-    onTestResults(listener: (trIds: string[]) => Promise<void>, options?: BatchOptions): void;
-    onTestFixtureResults(listener: (tfrIds: string[]) => Promise<void>, options?: BatchOptions): void;
-    onAttachmentFiles(listener: (afIds: string[]) => Promise<void>, options?: BatchOptions): void;
+export interface RealtimeSubscriber {
+    onGlobalAttachment(listener: (attachment: ResultFile) => Promise<void>): () => void;
+    onGlobalExitCode(listener: (payload: ExitCode) => Promise<void>): () => void;
+    onGlobalError(listener: (error: TestError) => Promise<void>): () => void;
+    onQualityGateResults(listener: (payload: QualityGateValidationResult[]) => Promise<void>): () => void;
+    onTestResults(listener: (trIds: string[]) => Promise<void>, options?: BatchOptions): () => void;
+    onTestFixtureResults(listener: (tfrIds: string[]) => Promise<void>, options?: BatchOptions): () => void;
+    onAttachmentFiles(listener: (afIds: string[]) => Promise<void>, options?: BatchOptions): () => void;
+}
+export interface RealtimeEventsDispatcher {
+    sendGlobalAttachment(attachment: ResultFile): void;
+    sendGlobalExitCode(payload: ExitCode): void;
+    sendGlobalError(error: TestError): void;
+    sendQualityGateResults(payload: QualityGateValidationResult[]): void;
+    sendTestResult(trId: string): void;
+    sendTestFixtureResult(tfrId: string): void;
+    sendAttachmentFile(afId: string): void;
 }
 export interface Plugin {
-    start?(context: PluginContext, store: AllureStore, realtime: Realtime): Promise<void>;
+    start?(context: PluginContext, store: AllureStore, realtime: RealtimeSubscriber): Promise<void>;
     update?(context: PluginContext, store: AllureStore): Promise<void>;
     done?(context: PluginContext, store: AllureStore): Promise<void>;
+    info?(context: PluginContext, store: AllureStore): Promise<PluginSummary>;
 }

package/dist/qualityGate.d.ts

@@ -1,44 +1,38 @@
-import type { AllureStore } from "./store.js";
-export type QualityGateRules = Record<string, any>;
-export type QualityGateRulesBaseMeta<T> = {
-    type: T;
-};
-export type QualityGateLabelsRulesMeta = QualityGateRulesBaseMeta<"label"> & {
-    name: string;
-    value: string;
-};
-export type QualityGateParametersRulesMeta = QualityGateRulesBaseMeta<"parameter"> & {
-    name: string;
-    value: string;
-};
-export type QualityGateLabelsEnforceConfig = {
-    type: "label";
-    name: string;
-    value: string;
-    rules: QualityGateRules;
-};
-export type QualityGateParametersEnforceConfig = {
-    type: "parameter";
-    name: string;
-    value: string;
-    rules: QualityGateRules;
-};
-export type QualityGateRulesMeta = Omit<QualityGateLabelsRulesMeta, "rules"> | Omit<QualityGateParametersRulesMeta, "rules">;
-export type QualityGateEnforceConfig = QualityGateLabelsEnforceConfig | QualityGateParametersEnforceConfig;
+import type { KnownTestFailure, TestResult } from "@allurereport/core-api";
 export type QualityGateValidationResult = {
     success: boolean;
+    expected: any;
+    actual: any;
     rule: string;
-    meta?: QualityGateRulesMeta;
-    expected?: number;
-    actual?: number;
-    message?: string;
+    message: string;
 };
-export interface QualityGateValidator {
-    validate(store: AllureStore): Promise<QualityGateValidationResult>;
+export type QualityGateRules = Record<string, any> & {
+    id?: string;
+    fastFail?: boolean;
+    filter?: (tr: TestResult) => boolean;
+};
+export type QualityGateRuleResult = {
+    success: boolean;
+    actual: any;
+};
+export interface QualityGateRuleState<T> {
+    getResult(): T | undefined;
+    setResult(value: T): void;
 }
-export type QualityGateValidatorConstructor = new (limit: number, meta?: QualityGateRulesMeta) => QualityGateValidator;
+export type QualityGateRule<T = any, K = T> = {
+    rule: string;
+    message: (payload: {
+        expected: T;
+        actual: T;
+    }) => string;
+    validate: (payload: {
+        expected: T;
+        trs: TestResult[];
+        knownIssues: KnownTestFailure[];
+        state: QualityGateRuleState<K>;
+    }) => Promise<QualityGateRuleResult>;
+};
 export type QualityGateConfig = {
-    rules?: QualityGateRules;
-    enforce?: QualityGateEnforceConfig[];
-    validators?: Record<string, QualityGateValidatorConstructor>;
+    rules?: QualityGateRules[];
+    use?: QualityGateRule[];
 };

package/dist/store.d.ts

@@ -1,15 +1,24 @@
-import type { AttachmentLink, HistoryDataPoint, HistoryTestResult, KnownTestFailure, Statistic, TestCase, TestFixtureResult, TestResult } from "@allurereport/core-api";
+import type { AttachmentLink, HistoryDataPoint, HistoryTestResult, KnownTestFailure, ReportVariables, Statistic, TestCase, TestEnvGroup, TestError, TestFixtureResult, TestResult } from "@allurereport/core-api";
+import type { ExitCode } from "./plugin.js";
+import type { QualityGateValidationResult } from "./qualityGate.js";
 import type { ResultFile } from "./resultFile.js";
+export type TestResultFilter = (testResult: TestResult) => boolean;
 export interface AllureStore {
     allTestCases: () => Promise<TestCase[]>;
     allTestResults: (options?: {
-        includeHidden: boolean;
+        includeHidden?: boolean;
     }) => Promise<TestResult[]>;
     allAttachments: () => Promise<AttachmentLink[]>;
     allMetadata: () => Promise<Record<string, any>>;
     allFixtures: () => Promise<TestFixtureResult[]>;
     allHistoryDataPoints: () => Promise<HistoryDataPoint[]>;
+    allHistoryDataPointsByEnvironment: (environment: string) => Promise<HistoryDataPoint[]>;
     allKnownIssues: () => Promise<KnownTestFailure[]>;
+    allNewTestResults: () => Promise<TestResult[]>;
+    qualityGateResults: () => Promise<QualityGateValidationResult[]>;
+    globalExitCode: () => Promise<ExitCode | undefined>;
+    allGlobalErrors: () => Promise<TestError[]>;
+    allGlobalAttachments: () => Promise<AttachmentLink[]>;
     testCaseById: (tcId: string) => Promise<TestCase | undefined>;
     testResultById: (trId: string) => Promise<TestResult | undefined>;
     attachmentById: (attachmentId: string) => Promise<AttachmentLink | undefined>;
@@ -17,8 +26,9 @@ export interface AllureStore {
     metadataByKey: <T>(key: string) => Promise<T | undefined>;
     testResultsByTcId: (tcId: string) => Promise<TestResult[]>;
     attachmentsByTrId: (trId: string) => Promise<AttachmentLink[]>;
+    retriesByTr: (tr: TestResult) => Promise<TestResult[]>;
     retriesByTrId: (trId: string) => Promise<TestResult[]>;
-    historyByTrId: (trId: string) => Promise<HistoryTestResult[]>;
+    historyByTrId: (trId: string) => Promise<HistoryTestResult[] | undefined>;
     fixturesByTrId: (trId: string) => Promise<TestFixtureResult[]>;
     failedTestResults: () => Promise<TestResult[]>;
     unknownFailedTestResults: () => Promise<TestResult[]>;
@@ -27,4 +37,45 @@ export interface AllureStore {
         [x: string]: TestResult[];
     }>;
     testsStatistic: (filter?: (testResult: TestResult) => boolean) => Promise<Statistic>;
+    allEnvironments: () => Promise<string[]>;
+    testResultsByEnvironment: (env: string) => Promise<TestResult[]>;
+    allTestEnvGroups: () => Promise<TestEnvGroup[]>;
+    allVariables: () => Promise<Record<string, any>>;
+    envVariables: (env: string) => Promise<Record<string, any>>;
+}
+export interface AllureStoreDump {
+    testResults: Record<string, TestResult>;
+    attachments: Record<string, AttachmentLink>;
+    globalAttachments: AttachmentLink[];
+    globalErrors: TestError[];
+    testCases: Record<string, TestCase>;
+    fixtures: Record<string, TestFixtureResult>;
+    environments: string[];
+    reportVariables: ReportVariables;
+    qualityGateResultsByRules: Record<string, QualityGateValidationResult>;
+    indexAttachmentByTestResult: Record<string, string[]>;
+    indexTestResultByHistoryId: Record<string, string[]>;
+    indexTestResultByTestCase: Record<string, string[]>;
+    indexLatestEnvTestResultByHistoryId: Record<string, string>;
+    indexAttachmentByFixture: Record<string, string[]>;
+    indexFixturesByTestResult: Record<string, string[]>;
+    indexKnownByHistoryId: Record<string, KnownTestFailure[]>;
+}
+export declare enum AllureStoreDumpFiles {
+    TestResults = "test-results.json",
+    TestCases = "test-cases.json",
+    Fixtures = "fixtures.json",
+    GlobalErrors = "global-errors.json",
+    GlobalAttachments = "global-attachments.json",
+    Attachments = "attachments.json",
+    Environments = "environments.json",
+    ReportVariables = "report-variables.json",
+    IndexAttachmentsByTestResults = "index-attachments-by-test-results.json",
+    IndexTestResultsByHistoryId = "index-test-results-by-history-id.json",
+    IndexTestResultsByTestCase = "index-test-results-by-test-case.json",
+    IndexLatestEnvTestResultsByHistoryId = "index-latest-env-test-results-by-history-id.json",
+    IndexAttachmentsByFixture = "index-attachments-by-fixture.json",
+    IndexFixturesByTestResult = "index-fixtures-by-test-result.json",
+    IndexKnownByHistoryId = "index-known-by-history-id.json",
+    QualityGateResultsByRules = "quality-gate-results-by-rules.json"
 }

package/dist/store.js

@@ -1 +1,19 @@
-export {};
+export var AllureStoreDumpFiles;
+(function (AllureStoreDumpFiles) {
+    AllureStoreDumpFiles["TestResults"] = "test-results.json";
+    AllureStoreDumpFiles["TestCases"] = "test-cases.json";
+    AllureStoreDumpFiles["Fixtures"] = "fixtures.json";
+    AllureStoreDumpFiles["GlobalErrors"] = "global-errors.json";
+    AllureStoreDumpFiles["GlobalAttachments"] = "global-attachments.json";
+    AllureStoreDumpFiles["Attachments"] = "attachments.json";
+    AllureStoreDumpFiles["Environments"] = "environments.json";
+    AllureStoreDumpFiles["ReportVariables"] = "report-variables.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["IndexLatestEnvTestResultsByHistoryId"] = "index-latest-env-test-results-by-history-id.json";
+    AllureStoreDumpFiles["IndexAttachmentsByFixture"] = "index-attachments-by-fixture.json";
+    AllureStoreDumpFiles["IndexFixturesByTestResult"] = "index-fixtures-by-test-result.json";
+    AllureStoreDumpFiles["IndexKnownByHistoryId"] = "index-known-by-history-id.json";
+    AllureStoreDumpFiles["QualityGateResultsByRules"] = "quality-gate-results-by-rules.json";
+})(AllureStoreDumpFiles || (AllureStoreDumpFiles = {}));

package/dist/utils/summary.d.ts

@@ -0,0 +1,3 @@
+import type { TestResult } from "@allurereport/core-api";
+import type { SummaryTestResult } from "../plugin.js";
+export declare const convertToSummaryTestResult: (tr: TestResult) => SummaryTestResult;

package/dist/utils/summary.js

@@ -0,0 +1,6 @@
+export const convertToSummaryTestResult = (tr) => ({
+    id: tr.id,
+    name: tr.name,
+    status: tr.status,
+    duration: tr.duration,
+});

package/dist/utils/tree.d.ts

@@ -2,7 +2,11 @@ import { type Comparator, type DefaultTreeGroup, type DefaultTreeLeaf, type Test
 export declare const byLabels: (item: TestResult, labelNames: string[]) => string[][];
 export declare const filterTreeLabels: (data: TestResult[], labelNames: string[]) => string[];
 export declare const createTreeByLabels: <T = TestResult, L = DefaultTreeLeaf, G = DefaultTreeGroup>(data: T[], labelNames: string[], leafFactory?: (item: T) => TreeLeaf<L>, groupFactory?: (parentGroup: string | undefined, groupClassifier: string) => TreeGroup<G>, addLeafToGroup?: (group: TreeGroup<G>, leaf: TreeLeaf<L>) => void) => TreeData<L, G>;
+export declare const createTreeByCategories: <T = TestResult, L = DefaultTreeLeaf, G = DefaultTreeGroup>(data: T[], leafFactory?: (item: T) => TreeLeaf<L>, groupFactory?: (parentGroup: string | undefined, groupClassifier: string) => TreeGroup<G>, addLeafToGroup?: (group: TreeGroup<G>, leaf: TreeLeaf<L>) => void) => TreeData<L, G>;
+export declare const byCategories: (item: TestResult) => string[][];
 export declare const preciseTreeLabels: <T = TestResult>(labelNames: string[], trs: T[], labelNamesAccessor?: (tr: T) => string[]) => string[];
 export declare const filterTree: <L, G>(tree: TreeData<L, G>, predicate: (leaf: TreeLeaf<L>) => boolean) => TreeData<L, G>;
 export declare const sortTree: <L, G>(tree: TreeData<L, G>, comparator: Comparator<TreeLeaf<L>>) => TreeData<L, G>;
 export declare const transformTree: <L, G>(tree: TreeData<L, G>, transformer: (leaf: TreeLeaf<L>, idx: number) => TreeLeaf<L>) => TreeData<L, G>;
+export declare const createTreeByTitlePath: <T = TestResult, L = DefaultTreeLeaf, G = DefaultTreeGroup>(data: T[], leafFactory?: (item: T) => TreeLeaf<L>, groupFactory?: (parentGroup: string | undefined, groupClassifier: string) => TreeGroup<G>, addLeafToGroup?: (group: TreeGroup<G>, leaf: TreeLeaf<L>) => void) => TreeData<L, G>;
+export declare const createTreeByLabelsAndTitlePath: <T = TestResult, L = DefaultTreeLeaf, G = DefaultTreeGroup>(data: T[], labelNames?: string[], leafFactory?: (item: T) => TreeLeaf<L>, groupFactory?: (parentGroup: string | undefined, groupClassifier: string) => TreeGroup<G>, addLeafToGroup?: (group: TreeGroup<G>, leaf: TreeLeaf<L>) => void) => TreeData<L, G>;

package/dist/utils/tree.js

@@ -87,6 +87,28 @@ export const createTreeByLabels = (data, labelNames, leafFactory, groupFactory,
         }));
     return createTree(data, (item) => byLabels(item, labelNames), leafFactoryFn, groupFactoryFn, addLeafToGroup);
 };
+export const createTreeByCategories = (data, leafFactory, groupFactory, addLeafToGroup = () => { }) => {
+    const leafFactoryFn = leafFactory ??
+        ((tr) => {
+            const { id, name, status, duration } = tr;
+            return {
+                nodeId: id,
+                name,
+                status,
+                duration,
+            };
+        });
+    const groupFactoryFn = groupFactory ??
+        ((parentId, groupClassifier) => ({
+            nodeId: md5((parentId ? `${parentId}.` : "") + groupClassifier),
+            name: groupClassifier,
+            statistic: emptyStatistic(),
+        }));
+    return createTree(data, (item) => byCategories(item), leafFactoryFn, groupFactoryFn, addLeafToGroup);
+};
+export const byCategories = (item) => {
+    return [item.categories?.map((category) => category.name)];
+};
 export const preciseTreeLabels = (labelNames, trs, labelNamesAccessor = (tr) => tr.labels.map(({ name }) => name)) => {
     const result = new Set();
     for (const labelName of labelNames) {
@@ -175,3 +197,58 @@ export const transformTree = (tree, transformer) => {
     transformGroupLeaves(root);
     return tree;
 };
+export const createTreeByTitlePath = (data, leafFactory, groupFactory, addLeafToGroup = () => { }) => {
+    const leafFactoryFn = leafFactory ??
+        ((tr) => {
+            const { id, name, status, duration } = tr;
+            return {
+                nodeId: id,
+                name,
+                status,
+                duration,
+            };
+        });
+    const groupFactoryFn = groupFactory ??
+        ((parentId, groupClassifier) => ({
+            nodeId: md5((parentId ? `${parentId}.` : "") + groupClassifier),
+            name: groupClassifier,
+            statistic: emptyStatistic(),
+        }));
+    return createTree(data, (item) => (item.titlePath ?? []).map((segment) => [segment]), leafFactoryFn, groupFactoryFn, addLeafToGroup);
+};
+const byLabelsAndTitlePath = (item, labelNames) => {
+    const leaves = [];
+    for (const labelName of labelNames) {
+        const values = item.labels.filter((label) => label.name === labelName).map((label) => label.value ?? "");
+        if (!values.length) {
+            continue;
+        }
+        leaves.push(values);
+    }
+    const titlePath = item.titlePath;
+    if (Array.isArray(titlePath) && titlePath.length > 0) {
+        for (const segment of titlePath) {
+            leaves.push([segment]);
+        }
+    }
+    return leaves;
+};
+export const createTreeByLabelsAndTitlePath = (data, labelNames = [], leafFactory, groupFactory, addLeafToGroup = () => { }) => {
+    const leafFactoryFn = leafFactory ??
+        ((tr) => {
+            const { id, name, status, duration } = tr;
+            return {
+                nodeId: id,
+                name,
+                status,
+                duration,
+            };
+        });
+    const groupFactoryFn = groupFactory ??
+        ((parentId, groupClassifier) => ({
+            nodeId: md5((parentId ? `${parentId}.` : "") + groupClassifier),
+            name: groupClassifier,
+            statistic: emptyStatistic(),
+        }));
+    return createTree(data, (item) => byLabelsAndTitlePath(item, labelNames), leafFactoryFn, groupFactoryFn, addLeafToGroup);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-api",
-  "version": "3.0.0-beta.8",
+  "version": "3.0.0",
   "description": "Allure Plugin API",
   "keywords": [
     "allure"
@@ -26,7 +26,7 @@
     "test": "rimraf ./out && vitest run"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.0.0-beta.8"
+    "@allurereport/core-api": "3.0.0"
   },
   "devDependencies": {
     "@stylistic/eslint-plugin": "^2.6.1",
@@ -34,9 +34,9 @@
     "@types/node": "^20.17.9",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
-    "@vitest/runner": "^2.1.8",
-    "@vitest/snapshot": "^2.1.8",
-    "allure-vitest": "^3.0.9",
+    "@vitest/runner": "^2.1.9",
+    "@vitest/snapshot": "^2.1.9",
+    "allure-vitest": "^3.3.3",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.29.1",
@@ -46,6 +46,6 @@
     "eslint-plugin-prefer-arrow": "^1.2.3",
     "rimraf": "^6.0.1",
     "typescript": "^5.6.3",
-    "vitest": "^2.1.8"
+    "vitest": "^2.1.9"
   }
 }