@allurereport/plugin-log 3.17.0 → 3.19.0

package/README.md

@@ -46,9 +46,28 @@ export default defineConfig({
 
 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`  |
+| 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                            | `suite \| feature \| package \| suites \| features \| packages \| none` | `suite`                         |
+| `qualityGateResults` | Include quality gate validation results in logs       | `boolean`                                           | `true`                          |
+| `qualityGateFilter`  | Select quality gate validation results shown in logs  | `(result: QualityGateValidationResult) => boolean`  | `({ success }) => !success`     |
 
+To show both successful and failed quality gate checks, configure the filter to include every result:
+
+```js
+export default {
+  plugins: {
+    log: {
+      options: {
+        qualityGateFilter: () => true,
+      },
+    },
+  },
+};
+```
+
+For `allure log`, use the `--all-quality-gate-results` flag to include successful quality gate checks. The command
+constructs its own log plugin configuration for that run, so plugin configuration from the Allure config file is not
+applied to `allure log`.

package/dist/model.d.ts

@@ -1,7 +1,10 @@
 import type { TestResult } from "@allurereport/core-api";
+import type { QualityGateValidationResult } from "@allurereport/plugin-api";
 export type LogPluginOptions = {
     allSteps?: boolean;
     withTrace?: boolean;
-    groupBy?: "suites" | "features" | "packages" | "none";
+    groupBy?: "suite" | "feature" | "package" | "suites" | "features" | "packages" | "none";
+    qualityGateResults?: boolean;
+    qualityGateFilter?: (result: QualityGateValidationResult) => boolean;
     filter?: (testResult: TestResult) => boolean;
 };

package/dist/plugin.js

@@ -1,42 +1,49 @@
 import * as console from "node:console";
 import { gray } from "yoctocolors";
-import { printSummary, printTest } from "./utils.js";
+import { printQualityGateResults, printSummary, printTest } from "./utils.js";
+const defaultQualityGateFilter = ({ success }) => !success;
 export class LogPlugin {
     constructor(options = {}) {
         this.options = options;
         this.done = async (context, store) => {
-            const { groupBy = "suite", filter = () => true } = this.options ?? {};
+            const { groupBy = "suite", filter = () => true, qualityGateResults = true, qualityGateFilter = defaultQualityGateFilter, } = this.options ?? {};
             const allTestResults = await store.allTestResults();
             const filteredTestResults = allTestResults.filter(filter);
+            const qualityGateResultsToPrint = qualityGateResults
+                ? (await store.qualityGateResults()).filter(qualityGateFilter)
+                : [];
             if (groupBy === "none") {
                 filteredTestResults.forEach((test) => {
                     printTest(test, this.options);
                 });
                 console.log("");
-                printSummary(filteredTestResults, { total: allTestResults.length, filtered: filteredTestResults.length });
-                return;
             }
-            const groupedTests = await store.testResultsByLabel(groupBy);
-            Object.keys(groupedTests).forEach((key) => {
-                const tests = groupedTests[key].filter(filter);
-                if (tests.length === 0) {
-                    return;
-                }
-                if (key === "_") {
-                    console.info(gray("uncategorized"));
-                }
-                else {
-                    console.info(key);
-                }
-                tests.forEach((test) => {
-                    printTest(test, this.options, 1);
+            else {
+                const groupedTests = await store.testResultsByLabel(groupBy);
+                Object.keys(groupedTests).forEach((key) => {
+                    const tests = groupedTests[key].filter(filter);
+                    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("");
                 });
-                console.log("");
-            });
+            }
             printSummary(filteredTestResults, {
                 total: allTestResults.length,
                 filtered: filteredTestResults.length,
             });
+            if (qualityGateResults) {
+                printQualityGateResults(qualityGateResultsToPrint);
+            }
         };
     }
 }

package/dist/utils.d.ts

@@ -1,4 +1,5 @@
 import type { DefaultTestStepResult, TestResult, TestStatus, TestStepResult } from "@allurereport/core-api";
+import type { QualityGateValidationResult } from "@allurereport/plugin-api";
 import type { LogPluginOptions } from "./model.js";
 export type PrintFunctionOptions = Pick<LogPluginOptions, "allSteps" | "groupBy" | "withTrace">;
 export declare const isFailedResult: (result: TestResult | TestStepResult) => boolean;
@@ -6,9 +7,12 @@ export declare const hasResultFailedSteps: (result: TestResult | TestStepResult)
 export declare const stringifyStatusBadge: (status: TestStatus) => string;
 export declare const stringifyTestResultTitle: (result: TestResult) => string;
 export declare const stringifyStepResultTitle: (result: DefaultTestStepResult) => string;
+export declare const stringifyQualityGateResultTitle: (result: QualityGateValidationResult) => 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[], options: {
     total: number;
     filtered: number;
 }) => void;
+export declare const printQualityGateResult: (result: QualityGateValidationResult, indent?: number) => void;
+export declare const printQualityGateResults: (results: QualityGateValidationResult[]) => void;

package/dist/utils.js

@@ -46,6 +46,11 @@ export const stringifyStepResultTitle = (result) => {
     const duration = result.duration ? `${yellow(`${result.duration}ms`)}` : "";
     return [status, result.name, duration].filter(Boolean).join(" ");
 };
+export const stringifyQualityGateResultTitle = (result) => {
+    const status = result.success ? green("✓") : red("⨯");
+    const environment = result.environment ? gray(`[${result.environment}]`) : "";
+    return [status, result.rule, environment].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);
@@ -140,3 +145,30 @@ export const printSummary = (results, options) => {
     console.info(`Tests: ${stringifiedCounters.join(" | ")}`);
     console.info(`Duration: ${yellow((totalDuration / 1000).toString())}s`);
 };
+export const printQualityGateResult = (result, indent = 0) => {
+    const indentSpaces = "  ".repeat(indent);
+    const message = result.success ? green(result.message) : red(result.message);
+    console.info(`${indentSpaces}${stringifyQualityGateResultTitle(result)}`);
+    console.info(`${indentSpaces}  ${message}`);
+};
+export const printQualityGateResults = (results) => {
+    if (results.length === 0) {
+        return;
+    }
+    console.log("");
+    console.info("Quality gates");
+    const orderedResults = [...results.filter(({ success }) => !success), ...results.filter(({ success }) => success)];
+    orderedResults.forEach((result) => {
+        printQualityGateResult(result, 1);
+    });
+    const passed = results.filter(({ success }) => success).length;
+    const failed = results.length - passed;
+    const stats = [];
+    if (passed > 0) {
+        stats.push(green(`${passed} passed`));
+    }
+    if (failed > 0) {
+        stats.push(red(`${failed} failed`));
+    }
+    console.info(`Quality gates: ${stats.join(" | ")}`);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-log",
-  "version": "3.17.0",
+  "version": "3.19.0",
   "description": "Allure Plugin to write report in stdout",
   "keywords": [
     "allure",
@@ -31,9 +31,9 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.17.0",
-    "@allurereport/plugin-api": "3.17.0",
-    "yoctocolors": "^2.1.2"
+    "@allurereport/core-api": "3.19.0",
+    "@allurereport/plugin-api": "3.19.0",
+    "yoctocolors": "^2.2.0"
   },
   "devDependencies": {
     "@types/node": "^20",