@allurereport/plugin-api 3.2.0 → 3.3.1

package/dist/config.d.ts

@@ -1,4 +1,4 @@
-import type { DefaultLabelsConfig, EnvironmentsConfig, ReportVariables } from "@allurereport/core-api";
+import type { CategoriesConfig, DefaultLabelsConfig, EnvironmentsConfig, ReportVariables } from "@allurereport/core-api";
 import type { PluginDescriptor } from "./plugin.js";
 import type { QualityGateConfig } from "./qualityGate.js";
 export interface Config {
@@ -10,7 +10,7 @@ export interface Config {
     historyLimit?: number;
     knownIssuesPath?: string;
     defaultLabels?: DefaultLabelsConfig;
-    stage?: string;
+    dump?: string;
     environment?: string;
     environments?: EnvironmentsConfig;
     variables?: ReportVariables;
@@ -20,5 +20,6 @@ export interface Config {
     allureService?: {
         accessToken?: string;
     };
+    categories?: CategoriesConfig;
 }
 export declare const defineConfig: (allureConfig: Config) => Config;

package/dist/plugin.d.ts

@@ -1,4 +1,4 @@
-import type { AttachmentLink, CiDescriptor, Statistic, TestError, TestResult, TestStatus } from "@allurereport/core-api";
+import type { AllureHistory, AttachmentLink, CategoryDefinition, 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";
@@ -26,6 +26,8 @@ export interface PluginContext {
     reportUrl?: string;
     output: string;
     ci?: CiDescriptor;
+    categories?: CategoryDefinition[];
+    history?: AllureHistory;
 }
 export type SummaryTestResult = Pick<TestResult, "name" | "id" | "status" | "duration">;
 export interface PluginSummary {

package/dist/store.d.ts

@@ -15,7 +15,7 @@ export interface AllureStore {
     allHistoryDataPoints: () => Promise<HistoryDataPoint[]>;
     allHistoryDataPointsByEnvironment: (environment: string) => Promise<HistoryDataPoint[]>;
     allKnownIssues: () => Promise<KnownTestFailure[]>;
-    allNewTestResults: (filter?: TestResultFilter) => Promise<TestResult[]>;
+    allNewTestResults: (filter?: TestResultFilter, history?: HistoryDataPoint[]) => Promise<TestResult[]>;
     qualityGateResults: () => Promise<QualityGateValidationResult[]>;
     qualityGateResultsByEnv: () => Promise<Record<string, QualityGateValidationResult[]>>;
     globalExitCode: () => Promise<ExitCode | undefined>;

package/dist/utils/summary.d.ts

@@ -1,3 +1,13 @@
-import type { TestResult } from "@allurereport/core-api";
-import type { SummaryTestResult } from "../plugin.js";
+import { type AllureHistory, type CiDescriptor, type TestResult } from "@allurereport/core-api";
+import type { PluginSummary, SummaryTestResult } from "../plugin.js";
+import type { AllureStore } from "../store.js";
 export declare const convertToSummaryTestResult: (tr: TestResult) => SummaryTestResult;
+export declare const createPluginSummary: (params: {
+    filter?: (testResult: TestResult) => boolean;
+    name: string;
+    plugin: string;
+    store: AllureStore;
+    history?: AllureHistory;
+    ci?: CiDescriptor;
+    meta: Record<string, any>;
+}) => Promise<PluginSummary>;

package/dist/utils/summary.js

@@ -1,6 +1,31 @@
+import { getWorstStatus } from "@allurereport/core-api";
 export const convertToSummaryTestResult = (tr) => ({
     id: tr.id,
     name: tr.name,
     status: tr.status,
     duration: tr.duration,
 });
+export const createPluginSummary = async (params) => {
+    const { name, filter, plugin, store, history, meta } = params;
+    const allTrs = await store.allTestResults({ filter });
+    const mainBranchHistory = (await history?.readHistory?.({ branch: "" })) ?? [];
+    const newTrs = await store.allNewTestResults(filter, mainBranchHistory);
+    const retryTrs = allTrs.filter((tr) => !!tr?.retries?.length);
+    const flakyTrs = allTrs.filter((tr) => !!tr?.flaky);
+    const duration = allTrs.reduce((acc, { duration: trDuration = 0 }) => acc + trDuration, 0);
+    const worstStatus = getWorstStatus(allTrs.map(({ status }) => status));
+    const createdAt = allTrs.reduce((acc, { stop }) => Math.max(acc, stop || 0), 0);
+    const summary = {
+        stats: await store.testsStatistic(filter),
+        status: worstStatus ?? "passed",
+        newTests: newTrs.map(convertToSummaryTestResult),
+        flakyTests: flakyTrs.map(convertToSummaryTestResult),
+        retryTests: retryTrs.map(convertToSummaryTestResult),
+        name,
+        duration,
+        createdAt,
+        plugin,
+        meta,
+    };
+    return summary;
+};

package/dist/utils/tree.js

@@ -1,4 +1,4 @@
-import { findByLabelName, } from "@allurereport/core-api";
+import { createDictionary, findByLabelName, } from "@allurereport/core-api";
 import { emptyStatistic } from "@allurereport/core-api";
 import { md5 } from "./misc.js";
 const addLeaf = (node, nodeId) => {
@@ -20,7 +20,7 @@ const addGroup = (node, nodeId) => {
     node.groups.push(nodeId);
 };
 const createTree = (data, classifier, leafFactory, groupFactory, addLeafToGroup = () => { }) => {
-    const groupsByClassifier = {};
+    const groupsByClassifier = createDictionary();
     const leavesById = {};
     const groupsById = {};
     const root = { groups: [], leaves: [] };
@@ -34,21 +34,26 @@ const createTree = (data, classifier, leafFactory, groupFactory, addLeafToGroup
                 break;
             }
             parentGroups = layer.flatMap((group) => {
-                return parentGroups.map((parentGroup) => {
+                return parentGroups.flatMap((parentGroup) => {
                     const parentId = "nodeId" in parentGroup ? parentGroup.nodeId : "";
                     if (groupsByClassifier[parentId] === undefined) {
-                        groupsByClassifier[parentId] = {};
+                        groupsByClassifier[parentId] = createDictionary();
                     }
-                    if (groupsByClassifier[parentId][group] === undefined ||
-                        typeof groupsByClassifier[parentId][group] === "function") {
+                    if (groupsByClassifier[parentId][group] === undefined) {
                         const newGroup = groupFactory(parentId, group);
+                        if (!newGroup || typeof newGroup !== "object" || typeof newGroup.nodeId !== "string") {
+                            return [];
+                        }
                         groupsByClassifier[parentId][group] = newGroup;
                         groupsById[newGroup.nodeId] = newGroup;
                     }
                     const currentGroup = groupsByClassifier[parentId][group];
+                    if (!currentGroup || typeof currentGroup !== "object") {
+                        return [];
+                    }
                     addGroup(parentGroup, currentGroup.nodeId);
                     addLeafToGroup(currentGroup, leaf);
-                    return currentGroup;
+                    return [currentGroup];
                 });
             });
         }
@@ -63,7 +68,9 @@ const createTree = (data, classifier, leafFactory, groupFactory, addLeafToGroup
     };
 };
 export const byLabels = (item, labelNames) => {
-    return labelNames.map((labelName) => item.labels.filter((label) => labelName === label.name).map((label) => label.value ?? "__unknown") ?? []);
+    return labelNames
+        .map((labelName) => item.labels.filter((label) => labelName === label.name).map((label) => label.value ?? "__unknown") ?? [])
+        .filter((layer) => layer.length > 0);
 };
 export const filterTreeLabels = (data, labelNames) => {
     return [...labelNames]
@@ -110,7 +117,15 @@ export const createTreeByCategories = (data, leafFactory, groupFactory, addLeafT
     return createTree(data, (item) => byCategories(item), leafFactoryFn, groupFactoryFn, addLeafToGroup);
 };
 export const byCategories = (item) => {
-    return [item.categories?.map((category) => category.name)];
+    const categories = item.categories ?? [];
+    const result = [];
+    for (const category of categories) {
+        result.push([category.name]);
+    }
+    if (item.error?.message) {
+        result.push([item.error?.message]);
+    }
+    return result;
 };
 export const preciseTreeLabels = (labelNames, trs, labelNamesAccessor = (tr) => tr.labels.map(({ name }) => name)) => {
     const result = new Set();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-api",
-  "version": "3.2.0",
+  "version": "3.3.1",
   "description": "Allure Plugin API",
   "keywords": [
     "allure"
@@ -26,7 +26,7 @@
     "test": "rimraf ./out && vitest run"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.2.0"
+    "@allurereport/core-api": "3.3.1"
   },
   "devDependencies": {
     "@stylistic/eslint-plugin": "^2.6.1",