@allurereport/core-api 3.0.0-beta.10

package/README.md

@@ -0,0 +1,25 @@
+# Core API
+
+[<img src="https://allurereport.org/public/img/allure-report.svg" height="85px" alt="Allure Report logo" align="right" />](https://allurereport.org "Allure Report")
+
+- Learn more about Allure Report at https://allurereport.org
+- 📚 [Documentation](https://allurereport.org/docs/) – discover official documentation for Allure Report
+- ❓ [Questions and Support](https://github.com/orgs/allure-framework/discussions/categories/questions-support) – get help from the team and community
+- 📢 [Official announcements](https://github.com/orgs/allure-framework/discussions/categories/announcements) – be in touch with the latest updates
+- 💬 [General Discussion ](https://github.com/orgs/allure-framework/discussions/categories/general-discussion) – engage in casual conversations, share insights and ideas with the community
+
+---
+
+## Overview
+
+The collection of interfaces describing the core Allure Report entities.
+
+## Install
+
+Use your favorite package manager to install the package:
+
+```shell
+npm add @allurereport/core-api
+yarn add @allurereport/core-api
+pnpm add @allurereport/core-api
+```

package/dist/aggregate.d.ts

@@ -0,0 +1,8 @@
+export type Statistic = {
+    failed?: number;
+    broken?: number;
+    passed?: number;
+    skipped?: number;
+    unknown?: number;
+    total: number;
+};

package/dist/aggregate.js

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

package/dist/config.d.ts

@@ -0,0 +1 @@
+export type DefaultLabelsConfig = Record<string, string | string[]>;

package/dist/config.js

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

package/dist/constants.d.ts

@@ -0,0 +1,21 @@
+import type { Statistic } from "./aggregate.js";
+import type { TestStatus } from "./model.js";
+export declare const statusesList: TestStatus[];
+export declare const unsuccessfulStatuses: Set<TestStatus>;
+export declare const successfulStatuses: Set<TestStatus>;
+export declare const includedInSuccessRate: Set<TestStatus>;
+export declare const filterByStatus: <T extends {
+    status: TestStatus;
+}>(statuses: Iterable<TestStatus>) => (t: T) => boolean;
+export declare const filterSuccessful: (t: {
+    status: TestStatus;
+}) => boolean;
+export declare const filterUnsuccessful: (t: {
+    status: TestStatus;
+}) => boolean;
+export declare const filterIncludedInSuccessRate: (t: {
+    status: TestStatus;
+}) => boolean;
+export declare const emptyStatistic: () => Statistic;
+export declare const incrementStatistic: (statistic: Statistic, status: TestStatus, count?: number) => void;
+export declare const mergeStatistic: (statistic: Statistic, additional: Statistic) => void;

package/dist/constants.js

@@ -0,0 +1,23 @@
+export const statusesList = ["failed", "broken", "passed", "skipped", "unknown"];
+export const unsuccessfulStatuses = new Set(["failed", "broken"]);
+export const successfulStatuses = new Set(["passed"]);
+export const includedInSuccessRate = new Set([...unsuccessfulStatuses, ...successfulStatuses]);
+export const filterByStatus = (statuses) => {
+    const set = new Set(statuses);
+    return (t) => set.has(t.status);
+};
+export const filterSuccessful = filterByStatus(successfulStatuses);
+export const filterUnsuccessful = filterByStatus(unsuccessfulStatuses);
+export const filterIncludedInSuccessRate = filterByStatus(includedInSuccessRate);
+export const emptyStatistic = () => ({ total: 0 });
+export const incrementStatistic = (statistic, status, count = 1) => {
+    statistic[status] = (statistic[status] ?? 0) + count;
+    statistic.total += count;
+};
+export const mergeStatistic = (statistic, additional) => {
+    statusesList.forEach((status) => {
+        if (additional[status]) {
+            incrementStatistic(statistic, status, additional[status]);
+        }
+    });
+};

package/dist/environment.d.ts

@@ -0,0 +1,19 @@
+import type { TestLabel } from "./metadata.js";
+import type { TestResult } from "./model.js";
+export interface EnvironmentItem {
+    name: string;
+    values: string[];
+}
+export type ReportVariables = Record<string, string>;
+export type EnvironmentMatcherPayload = {
+    labels: TestLabel[];
+};
+export type EnvironmentDescriptor = {
+    variables?: ReportVariables;
+    matcher: (payload: EnvironmentMatcherPayload) => boolean;
+};
+export type EnvironmentsConfig = Record<string, EnvironmentDescriptor>;
+export type EnvTestGroup = Pick<TestResult, "fullName" | "name" | "status"> & {
+    id: string;
+    testResultsByEnv: Record<string, TestResult>;
+};

package/dist/environment.js

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

package/dist/history.d.ts

@@ -0,0 +1,19 @@
+import type { TestError, TestStatus } from "./model.js";
+export interface HistoryTestResult {
+    id: string;
+    name: string;
+    fullName?: string;
+    status: TestStatus;
+    error?: TestError;
+    start?: number;
+    stop?: number;
+    duration?: number;
+}
+export interface HistoryDataPoint {
+    uuid: string;
+    name: string;
+    timestamp: number;
+    knownTestCaseIds: string[];
+    testResults: Record<string, HistoryTestResult>;
+    metrics: Record<string, number>;
+}

package/dist/history.js

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

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export type * from "./aggregate.js";
+export * from "./constants.js";
+export type * from "./environment.js";
+export type * from "./history.js";
+export type * from "./known.js";
+export type * from "./metadata.js";
+export type * from "./model.js";
+export type * from "./testCase.js";
+export type * from "./testPlan.js";
+export type * from "./config.js";
+export * from "./utils/step.js";
+export type * from "./utils/tree.js";
+export * from "./utils/time.js";
+export * from "./utils/comparator.js";
+export * from "./utils/predicate.js";
+export * from "./utils/label.js";
+export * from "./utils/testplan.js";
+export * from "./utils/status.js";
+export * from "./utils/environment.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from "./constants.js";
+export * from "./utils/step.js";
+export * from "./utils/time.js";
+export * from "./utils/comparator.js";
+export * from "./utils/predicate.js";
+export * from "./utils/label.js";
+export * from "./utils/testplan.js";
+export * from "./utils/status.js";
+export * from "./utils/environment.js";

package/dist/known.d.ts

@@ -0,0 +1,8 @@
+import type { TestLink } from "./metadata.js";
+import type { TestError } from "./model.js";
+export interface KnownTestFailure {
+    historyId: string;
+    issues?: TestLink[];
+    comment?: string;
+    error?: TestError;
+}

package/dist/known.js

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

package/dist/metadata.d.ts

@@ -0,0 +1,16 @@
+export interface TestLabel {
+    name: string;
+    value?: string;
+}
+export interface TestLink {
+    name?: string;
+    url: string;
+    type?: string;
+}
+export interface TestParameter {
+    name: string;
+    value: string;
+    hidden: boolean;
+    excluded: boolean;
+    masked: boolean;
+}

package/dist/metadata.js

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

package/dist/model.d.ts

@@ -0,0 +1,102 @@
+import type { TestLabel, TestLink, TestParameter } from "./metadata.js";
+import type { TestCase } from "./testCase.js";
+export type TestStatus = "failed" | "broken" | "passed" | "skipped" | "unknown";
+export interface SourceMetadata {
+    readerId: string;
+    metadata: {
+        [key: string]: any;
+    };
+}
+export interface TestError {
+    message?: string;
+    trace?: string;
+    actual?: string;
+    expected?: string;
+}
+export interface TestResult {
+    id: string;
+    name: string;
+    status: TestStatus;
+    error?: TestError;
+    testCase?: TestCase;
+    environment?: string;
+    fullName?: string;
+    historyId?: string;
+    description?: string;
+    descriptionHtml?: string;
+    precondition?: string;
+    preconditionHtml?: string;
+    expectedResult?: string;
+    expectedResultHtml?: string;
+    start?: number;
+    stop?: number;
+    duration?: number;
+    flaky: boolean;
+    muted: boolean;
+    known: boolean;
+    hidden: boolean;
+    hostId?: string;
+    threadId?: string;
+    labels: TestLabel[];
+    parameters: TestParameter[];
+    links: TestLink[];
+    steps: TestStepResult[];
+    sourceMetadata: SourceMetadata;
+    runSelector?: string;
+    retries?: TestResult[];
+    categories?: any;
+}
+export interface TestFixtureResult {
+    id: string;
+    testResultIds: string[];
+    type: "before" | "after";
+    name: string;
+    status: TestStatus;
+    error?: TestError;
+    start?: number;
+    stop?: number;
+    duration?: number;
+    steps: TestStepResult[];
+    sourceMetadata: SourceMetadata;
+}
+export type TestStepResult = DefaultTestStepResult | AttachmentTestStepResult;
+export interface DefaultTestStepResult {
+    name: string;
+    parameters: TestParameter[];
+    status: TestStatus;
+    error?: TestError;
+    start?: number;
+    stop?: number;
+    duration?: number;
+    steps: TestStepResult[];
+    stepId?: string;
+    type: "step";
+}
+export interface AttachmentLinkFile {
+    id: string;
+    contentType?: string;
+    contentLength?: number;
+    originalFileName: string;
+    ext: string;
+    used: false;
+    missed: false;
+}
+export interface AttachmentLinkExpected {
+    id: string;
+    name: string;
+    contentType?: string;
+    originalFileName: string;
+    ext: string;
+    used: true;
+    missed: true;
+}
+export type AttachmentLinkLinked = Omit<AttachmentLinkFile, "used"> & Omit<AttachmentLinkExpected, "missed">;
+export type AttachmentLinkInvalid = Omit<AttachmentLinkExpected, "originalFileName" | "ext"> & {
+    originalFileName: undefined;
+    ext: "";
+};
+export type AttachmentLink = AttachmentLinkFile | AttachmentLinkExpected | AttachmentLinkLinked | AttachmentLinkInvalid;
+export interface AttachmentTestStepResult {
+    link: AttachmentLinkExpected | AttachmentLinkLinked | AttachmentLinkInvalid;
+    type: "attachment";
+}

package/dist/model.js

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

package/dist/testCase.d.ts

@@ -0,0 +1,6 @@
+export interface TestCase {
+    id: string;
+    allureId?: string;
+    name: string;
+    fullName?: string;
+}

package/dist/testCase.js

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

package/dist/testPlan.d.ts

@@ -0,0 +1,8 @@
+export interface TestPlanTest {
+    id?: string;
+    selector?: string;
+}
+export interface TestPlan {
+    version: "1.0";
+    tests: TestPlanTest[];
+}

package/dist/testPlan.js

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

package/dist/utils/comparator.d.ts

@@ -0,0 +1,19 @@
+import type { Statistic } from "../aggregate.js";
+import type { TestStatus } from "../model.js";
+export type SortFunction<T> = () => Comparator<T>;
+export type Comparator<T> = (a: T, b: T) => number;
+type Value<T, P> = T extends any ? (P extends keyof T ? T[P] : P extends "" ? T : never) : never;
+export declare const reverse: <T>(comparator: Comparator<T>) => Comparator<T>;
+export declare const nullsLast: <T extends {}>(compare: Comparator<T>) => Comparator<T | undefined>;
+export declare const nullsFirst: <T extends {}>(compare: Comparator<T>) => Comparator<T | undefined>;
+export declare const nullsDefault: <T extends {}>(compare: Comparator<T>, defaultValue: T) => Comparator<T | undefined>;
+export declare const compareBy: <T extends Record<string, any> = {}, P extends keyof T = keyof T>(property: P, compare: Comparator<Value<T, P>>, defaultValue?: T[P]) => Comparator<T>;
+export declare const andThen: <T>(comparators: Comparator<T>[]) => Comparator<T>;
+export declare const alphabetically: SortFunction<string | undefined>;
+export declare const ordinal: SortFunction<number | undefined>;
+export declare const byStatus: SortFunction<TestStatus | undefined>;
+export declare const byStatistic: SortFunction<Statistic | undefined>;
+export declare const byName: SortFunction<Partial<{
+    name: string;
+}> | undefined>;
+export {};

package/dist/utils/comparator.js

@@ -0,0 +1,47 @@
+import { statusesList } from "../constants.js";
+export const reverse = (comparator) => {
+    return (a, b) => comparator(b, a);
+};
+export const nullsLast = (compare) => {
+    return (a, b) => a === b ? 0 : a === undefined || a === null ? 1 : b === undefined || b === null ? -1 : compare(a, b);
+};
+export const nullsFirst = (compare) => {
+    return (a, b) => a === b ? 0 : a === undefined || a === null ? -1 : b === undefined || b === null ? 1 : compare(a, b);
+};
+export const nullsDefault = (compare, defaultValue) => {
+    return (a, b) => compare(a ?? defaultValue, b ?? defaultValue);
+};
+export const compareBy = (property, compare, defaultValue) => {
+    return nullsLast((a, b) => {
+        if (defaultValue !== undefined) {
+            return compare(a[property] ?? defaultValue, b[property] ?? defaultValue);
+        }
+        if (property in a && property in b) {
+            return compare(a[property], b[property]);
+        }
+        return 0;
+    });
+};
+export const andThen = (comparators) => {
+    return (a, b) => {
+        for (const compare of comparators) {
+            const res = compare(a, b);
+            if (res !== 0) {
+                return res;
+            }
+        }
+        return 0;
+    };
+};
+export const alphabetically = () => nullsLast((a, b) => a.localeCompare(b));
+export const ordinal = () => nullsLast((a, b) => a - b);
+export const byStatus = () => {
+    return nullsLast((a, b) => {
+        return statusesList.indexOf(a) - statusesList.indexOf(b);
+    });
+};
+export const byStatistic = () => {
+    const compares = statusesList.map((status) => compareBy(status, reverse(ordinal()), 0));
+    return nullsLast(andThen(compares));
+};
+export const byName = () => nullsLast(compareBy("name", alphabetically()));

package/dist/utils/environment.d.ts

@@ -0,0 +1,3 @@
+import type { EnvironmentsConfig } from "../environment.js";
+import type { TestResult } from "../model.js";
+export declare const matchEnvironment: (envConfig: EnvironmentsConfig, tr: TestResult) => string;

package/dist/utils/environment.js

@@ -0,0 +1,3 @@
+export const matchEnvironment = (envConfig, tr) => {
+    return Object.entries(envConfig).find(([, { matcher }]) => matcher({ labels: tr.labels }))?.[0] ?? "default";
+};

package/dist/utils/label.d.ts

@@ -0,0 +1,2 @@
+import type { TestLabel } from "../index.js";
+export declare const findByLabelName: (labels: TestLabel[], name: string) => string | undefined;

package/dist/utils/label.js

@@ -0,0 +1,3 @@
+export const findByLabelName = (labels, name) => {
+    return labels.find((label) => label.name === name)?.value;
+};

package/dist/utils/predicate.d.ts

@@ -0,0 +1 @@
+export declare const notNull: <T>(value: T) => value is NonNullable<T>;

package/dist/utils/predicate.js

@@ -0,0 +1 @@
+export const notNull = (value) => !!value;

package/dist/utils/status.d.ts

@@ -0,0 +1,4 @@
+import type { TestStatus } from "../model.js";
+export declare const StatusByPriority: TestStatus[];
+export declare const statusToPriority: (status: TestStatus | undefined) => number;
+export declare const getWorstStatus: (items: TestStatus[]) => TestStatus | undefined;

package/dist/utils/status.js

@@ -0,0 +1,13 @@
+export const StatusByPriority = ["failed", "broken", "passed", "skipped", "unknown"];
+export const statusToPriority = (status) => {
+    if (!status) {
+        return -1;
+    }
+    return StatusByPriority.indexOf(status);
+};
+export const getWorstStatus = (items) => {
+    if (items.length === 0) {
+        return;
+    }
+    return items.sort((a, b) => statusToPriority(a) - statusToPriority(b))[0];
+};

package/dist/utils/step.d.ts

@@ -0,0 +1,3 @@
+import type { AttachmentTestStepResult, DefaultTestStepResult, TestStepResult } from "../model.js";
+export declare const isStep: (result: TestStepResult) => result is DefaultTestStepResult;
+export declare const isAttachment: (result: TestStepResult) => result is AttachmentTestStepResult;

package/dist/utils/step.js

@@ -0,0 +1,6 @@
+export const isStep = (result) => {
+    return result.type === "step";
+};
+export const isAttachment = (result) => {
+    return result.type === "attachment";
+};

package/dist/utils/testplan.d.ts

@@ -0,0 +1,2 @@
+import type { TestPlan, TestResult } from "../index.js";
+export declare const createTestPlan: (testResults: TestResult[]) => TestPlan;

package/dist/utils/testplan.js

@@ -0,0 +1,13 @@
+import { findByLabelName } from "./label.js";
+export const createTestPlan = (testResults) => {
+    const seenIds = new Set();
+    const seenSelectors = new Set();
+    const tests = testResults
+        .map((tr) => ({ selector: tr.runSelector ?? tr.fullName, id: findByLabelName(tr.labels, "ALLURE_ID") }))
+        .filter((value) => (value.selector && (seenSelectors.has(value.selector) ? false : !!seenSelectors.add(value.selector))) ||
+        (value.id && (seenIds.has(value.id) ? false : !!seenSelectors.add(value.id))));
+    return {
+        version: "1.0",
+        tests,
+    };
+};

package/dist/utils/time.d.ts

@@ -0,0 +1 @@
+export declare const formatDuration: (duration?: number) => string;

package/dist/utils/time.js

@@ -0,0 +1,42 @@
+const times = [
+    {
+        suffix: "d",
+        accessor: (duration) => Math.floor(duration / (24 * 3600 * 1000)),
+    },
+    {
+        suffix: "h",
+        accessor: (duration) => Math.floor(duration / (3600 * 1000)) % 24,
+    },
+    {
+        suffix: "m",
+        accessor: (duration) => Math.floor(duration / (60 * 1000)) % 60,
+    },
+    {
+        suffix: "s",
+        accessor: (duration) => Math.floor(duration / 1000) % 60,
+    },
+    {
+        suffix: "ms",
+        accessor: (duration) => Math.round(duration) % 1000,
+    },
+];
+export const formatDuration = (duration) => {
+    if (duration === undefined) {
+        return "unknown";
+    }
+    if (duration < 0.5) {
+        return "0s";
+    }
+    const res = [];
+    for (const { accessor, suffix } of times) {
+        const value = accessor(duration);
+        if (res.length === 0 && !value) {
+            continue;
+        }
+        res.push(value + suffix);
+        if (res.length > 1) {
+            break;
+        }
+    }
+    return res.join(" ");
+};

package/dist/utils/tree.d.ts

@@ -0,0 +1,22 @@
+import type { Statistic } from "../aggregate.js";
+import type { TestResult } from "../model.js";
+type TreeNode<T> = Omit<T, "nodeId"> & {
+    nodeId: string;
+};
+export interface WithChildren {
+    groups?: string[];
+    leaves?: string[];
+}
+export type TreeGroup<T> = TreeNode<T> & WithChildren;
+export type TreeLeaf<T> = TreeNode<T>;
+export type TreeData<L, G> = {
+    root: WithChildren;
+    leavesById: Record<string, TreeLeaf<L>>;
+    groupsById: Record<string, TreeGroup<G>>;
+};
+export type DefaultTreeLeaf = Pick<TestResult, "name" | "status" | "duration">;
+export type DefaultTreeGroup = {
+    name: string;
+    statistic: Statistic;
+};
+export {};

package/dist/utils/tree.js

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

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@allurereport/core-api",
+  "version": "3.0.0-beta.10",
+  "description": "Allure Core API",
+  "keywords": [
+    "allure"
+  ],
+  "repository": "https://github.com/allure-framework/allure3",
+  "license": "Apache-2.0",
+  "author": "Qameta Software",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "run clean && tsc --project ./tsconfig.json",
+    "clean": "rimraf ./dist",
+    "eslint": "eslint ./src/**/*.{js,jsx,ts,tsx}",
+    "eslint:format": "eslint --fix ./src/**/*.{js,jsx,ts,tsx}",
+    "test": "rimraf ./out && vitest run"
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2.6.1",
+    "@types/eslint": "^8.56.11",
+    "@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",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-jsdoc": "^50.0.0",
+    "eslint-plugin-n": "^17.10.1",
+    "eslint-plugin-no-null": "^1.0.2",
+    "eslint-plugin-prefer-arrow": "^1.2.3",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
+  }
+}