@allurereport/plugin-log 3.0.0-beta.10

package/README.md

@@ -0,0 +1,54 @@
+# Log Plugin
+
+[<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
+
+This plugin prints report in the terminal.
+
+## Install
+
+Use your favorite package manager to install the package:
+
+```shell
+npm add @allurereport/plugin-log
+yarn add @allurereport/plugin-log
+pnpm add @allurereport/plugin-log
+```
+
+Then, add the plugin to the Allure configuration file:
+
+```diff
+import { defineConfig } from "allure";
+
+export default defineConfig({
+  name: "Allure Report",
+  output: "./allure-report",
+  historyPath: "./history.jsonl",
+  plugins: {
++    log: {
++      options: {
++      },
++    },
+  },
+});
+```
+
+## Options
+
+The plugin accepts the following options:
+
+| Option      | Description                      | Type                                     | Default |
+|-------------|----------------------------------|------------------------------------------|---------|
+| `allSteps`  | Include all steps in the report  | `boolean`                                | `false` |
+| `withTrace` | Include step trace in the report | `boolean`                                | `false` |
+| `groupBy`   | Group tests by given label       | `suites \| features \| packages \| none` | `none`  |
+

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { LogPlugin } from "./plugin.js";
+export default LogPlugin;

package/dist/index.js

@@ -0,0 +1,2 @@
+import { LogPlugin } from "./plugin.js";
+export default LogPlugin;

package/dist/model.d.ts

@@ -0,0 +1,5 @@
+export type LogPluginOptions = {
+    allSteps?: boolean;
+    withTrace?: boolean;
+    groupBy?: "suites" | "features" | "packages" | "none";
+};

package/dist/model.js

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

package/dist/plugin.d.ts

@@ -0,0 +1,7 @@
+import type { AllureStore, Plugin, PluginContext } from "@allurereport/plugin-api";
+import type { LogPluginOptions } from "./model.js";
+export declare class LogPlugin implements Plugin {
+    readonly options: LogPluginOptions;
+    constructor(options?: LogPluginOptions);
+    done: (context: PluginContext, store: AllureStore) => Promise<void>;
+}

package/dist/plugin.js

@@ -0,0 +1,38 @@
+import * as console from "node:console";
+import { gray } from "yoctocolors";
+import { printSummary, printTest } from "./utils.js";
+export class LogPlugin {
+    constructor(options = {}) {
+        this.options = options;
+        this.done = async (context, store) => {
+            const { groupBy = "suite" } = this.options ?? {};
+            const allTestResults = await store.allTestResults();
+            if (groupBy === "none") {
+                allTestResults.forEach((test) => {
+                    printTest(test, this.options);
+                });
+                console.log("");
+                printSummary(Array.from(allTestResults));
+                return;
+            }
+            const groupedTests = await store.testResultsByLabel(groupBy);
+            Object.keys(groupedTests).forEach((key) => {
+                const tests = groupedTests[key];
+                if (tests.length === 0) {
+                    return;
+                }
+                if (key === "_") {
+                    console.info(gray("uncategorized"));
+                }
+                else {
+                    console.info(key);
+                }
+                tests.forEach((test) => {
+                    printTest(test, this.options, 1);
+                });
+                console.log("");
+            });
+            printSummary(Array.from(allTestResults));
+        };
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,11 @@
+import type { DefaultTestStepResult, TestResult, TestStatus, TestStepResult } from "@allurereport/core-api";
+import type { LogPluginOptions } from "./model.js";
+export type PrintFunctionOptions = Pick<LogPluginOptions, "allSteps" | "groupBy" | "withTrace">;
+export declare const isFailedResult: (result: TestResult | TestStepResult) => boolean;
+export declare const hasResultFailedSteps: (result: TestResult | TestStepResult) => boolean;
+export declare const stringifyStatusBadge: (status: TestStatus) => string;
+export declare const stringifyTestResultTitle: (result: TestResult) => string;
+export declare const stringifyStepResultTitle: (result: DefaultTestStepResult) => string;
+export declare const printTest: (test: TestResult, options?: PrintFunctionOptions, indent?: number) => void;
+export declare const printStep: (step: DefaultTestStepResult, options?: PrintFunctionOptions, indent?: number) => void;
+export declare const printSummary: (results: TestResult[]) => void;

package/dist/utils.js

@@ -0,0 +1,136 @@
+import { isStep } from "@allurereport/core-api";
+import console from "node:console";
+import { gray, green, red, yellow } from "yoctocolors";
+export const isFailedResult = (result) => {
+    if ("status" in result) {
+        return result.status === "failed" || result.status === "broken";
+    }
+    return false;
+};
+export const hasResultFailedSteps = (result) => {
+    if (!("steps" in result)) {
+        return false;
+    }
+    return result.steps?.some((step) => {
+        if (isFailedResult(step)) {
+            return true;
+        }
+        if (step.type === "step" && step?.steps) {
+            return hasResultFailedSteps(step);
+        }
+        return false;
+    });
+};
+export const stringifyStatusBadge = (status) => {
+    switch (status) {
+        case "passed":
+            return green("✓");
+        case "failed":
+            return red("⨯");
+        case "broken":
+            return red("⨯");
+        case "skipped":
+            return gray("-");
+        case "unknown":
+            return gray("?");
+    }
+};
+export const stringifyTestResultTitle = (result) => {
+    const status = stringifyStatusBadge(result.status);
+    const name = result.name;
+    const duration = result.duration ? `${yellow(`${result.duration}ms`)}` : "";
+    return [status, name, duration].filter(Boolean).join(" ");
+};
+export const stringifyStepResultTitle = (result) => {
+    const status = stringifyStatusBadge(result.status);
+    const duration = result.duration ? `${yellow(`${result.duration}ms`)}` : "";
+    return [status, result.name, duration].filter(Boolean).join(" ");
+};
+export const printTest = (test, options, indent = 0) => {
+    const title = stringifyTestResultTitle(test);
+    const stepsToPrint = options?.allSteps ? test.steps.filter(isStep) : test.steps.filter(isFailedResult).filter(isStep);
+    const failedResult = isFailedResult(test);
+    const indentSpaces = "  ".repeat(indent);
+    console.info(`${indentSpaces}${title}`);
+    if (failedResult && test.error?.message) {
+        console.info(`${indentSpaces}  ${red(test.error.message)}`);
+    }
+    if (options?.withTrace && failedResult && test.error?.trace) {
+        test.error.trace.split("\n").forEach((line) => {
+            console.info(`${indentSpaces}  ${gray(line)}`);
+        });
+    }
+    if (!stepsToPrint?.length) {
+        return;
+    }
+    stepsToPrint.forEach((step) => {
+        printStep(step, options, indent + 1);
+    });
+};
+export const printStep = (step, options, indent = 0) => {
+    const title = stringifyStepResultTitle(step);
+    const stepsToPrint = (options?.allSteps ? step.steps.filter(isStep) : step.steps?.filter(isStep).filter(isFailedResult)) || [];
+    const indentSpaces = "  ".repeat(indent);
+    const failedResult = isFailedResult(step);
+    console.info(`${indentSpaces}${title}`);
+    if (failedResult && step.error?.message) {
+        console.info(`  ${indentSpaces}${red(step.error?.message)}`);
+    }
+    if (options?.withTrace && failedResult && step.error?.trace) {
+        step.error.trace.split("\n").forEach((line) => {
+            console.info(`  ${indentSpaces}${gray(line)}`);
+        });
+    }
+    if (!stepsToPrint?.length) {
+        return;
+    }
+    stepsToPrint.forEach((child) => {
+        printStep(child, options, indent + 1);
+    });
+};
+export const printSummary = (results) => {
+    const statsCounters = {
+        passed: 0,
+        failed: 0,
+        broken: 0,
+        skipped: 0,
+    };
+    let totalDuration = 0;
+    results.forEach((test) => {
+        totalDuration += test.duration || 0;
+        switch (test.status) {
+            case "passed":
+                statsCounters.passed++;
+                break;
+            case "failed":
+                statsCounters.failed++;
+                break;
+            case "broken":
+                statsCounters.broken++;
+                break;
+            case "skipped":
+                statsCounters.skipped++;
+                break;
+        }
+    });
+    const stringifiedCounters = [];
+    if (statsCounters.passed > 0) {
+        stringifiedCounters.push(green(`${statsCounters.passed} passed`));
+    }
+    if (statsCounters.failed > 0) {
+        stringifiedCounters.push(red(`${statsCounters.failed} failed`));
+    }
+    if (statsCounters.broken > 0) {
+        stringifiedCounters.push(red(`${statsCounters.broken} broken`));
+    }
+    if (statsCounters.skipped > 0) {
+        stringifiedCounters.push(yellow(`${statsCounters.skipped} skipped`));
+    }
+    if (results.length === 0) {
+        console.info("No test results found to show");
+        return;
+    }
+    console.info(`Total tests: ${results.length}`);
+    console.info(`Tests: ${stringifiedCounters.join(" | ")}`);
+    console.info(`Duration: ${yellow((totalDuration / 1000).toString())}s`);
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@allurereport/plugin-log",
+  "version": "3.0.0-beta.10",
+  "description": "Allure Plugin to write report in stdout",
+  "keywords": [
+    "allure",
+    "testing",
+    "report",
+    "plugin",
+    "cli",
+    "stdout"
+  ],
+  "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"
+  },
+  "dependencies": {
+    "@allurereport/core-api": "3.0.0-beta.10",
+    "@allurereport/plugin-api": "3.0.0-beta.10",
+    "yoctocolors": "^2.1.1"
+  },
+  "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"
+  }
+}