allure-report-publisher 5.0.0-alpha.0

package/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Andrejs Cunskis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,253 @@
+# allure-report-publisher
+
+[![Docker Image Version (latest semver)](https://img.shields.io/docker/v/andrcuns/allure-report-publisher?color=blue&label=docker&sort=semver)](https://hub.docker.com/r/andrcuns/allure-report-publisher)
+[![Docker Pulls](https://img.shields.io/docker/pulls/andrcuns/allure-report-publisher)](https://hub.docker.com/r/andrcuns/allure-report-publisher)
+![Workflow status](https://github.com/andrcuns/allure-report-publisher/workflows/Test/badge.svg)
+
+Upload your report to a file storage of your choice.
+
+![Demo](demo.gif)
+
+# Usage
+
+<!-- usage -->
+```sh-session
+$ npm install -g allure-report-publisher
+$ allure-report-publisher COMMAND
+running command...
+$ allure-report-publisher (--version)
+allure-report-publisher/5.0.0-alpha.0 linux-x64 node-v25.2.1
+$ allure-report-publisher --help [COMMAND]
+USAGE
+  $ allure-report-publisher COMMAND
+...
+```
+<!-- usagestop -->
+<!-- commands -->
+* [`allure-report-publisher upload TYPE`](#allure-report-publisher-upload-type)
+
+## `allure-report-publisher upload TYPE`
+
+Generate and upload allure report to cloud storage
+
+```
+USAGE
+  $ allure-report-publisher upload TYPE [--baseUrl <value>] [-r <value>] [-b <value>] [-p <value>] [-c
+    <value>] [--reportName <value>] [--ciReportTitle <value>] [--summary behaviors|suites|packages|total]
+    [--summaryTableType ascii|markdown] [--updatePr comment|description|actions] [--collapseSummary] [--color]
+    [--copyLatest] [--debug] [--flakyWarningStatus] [--ignoreMissingResults] [-o <value>] [--parallel <value>]
+
+ARGUMENTS
+  TYPE  (s3|gcs|gitlab-artifacts) Cloud storage provider type
+
+FLAGS
+  -b, --bucket=<value>             [env: ALLURE_BUCKET] Cloud storage bucket name (required for s3/gcs)
+  -c, --config=<value>             [env: ALLURE_CONFIG_PATH] The path to allure config file (only .json or .yaml are
+                                   supported)
+  -o, --output=<value>             [env: ALLURE_OUTPUT] Output directory for generated report (default: temp dir for
+                                   cloud, "allure-report" for gitlab-artifacts)
+  -p, --prefix=<value>             [env: ALLURE_PREFIX] Prefix for report path in cloud storage (ignored for
+                                   gitlab-artifacts)
+  -r, --resultsGlob=<value>        [default: ./**/allure-results, env: ALLURE_RESULTS_GLOB] Glob pattern for allure
+                                   results directories
+      --baseUrl=<value>            [env: ALLURE_BASE_URL] Custom base URL for report links
+      --ciReportTitle=<value>      [default: Allure Report, env: ALLURE_CI_REPORT_TITLE] Title for PR
+                                   comment/description section
+      --collapseSummary            [env: ALLURE_COLLAPSE_SUMMARY] Create collapsible summary section in PR
+      --[no-]color                 [env: ALLURE_COLOR] Force color output
+      --copyLatest                 [env: ALLURE_COPY_LATEST] Keep copy of latest run report at base prefix (ignored for
+                                   gitlab-artifacts)
+      --debug                      [env: ALLURE_DEBUG] Print debug log output
+      --flakyWarningStatus         [env: ALLURE_FLAKY_WARNING_STATUS] Mark run with ! status if flaky tests found
+      --ignoreMissingResults       [env: ALLURE_IGNORE_MISSING_RESULTS] Ignore missing allure results
+      --parallel=<value>           [default: 8, env: ALLURE_PARALLEL] Number of parallel threads for upload
+      --reportName=<value>         [env: ALLURE_REPORT_NAME] Custom report name in Allure report (ignored with
+                                   config-path)
+      --summary=<option>           [default: total, env: ALLURE_SUMMARY] Add test summary table to PR
+                                   <options: behaviors|suites|packages|total>
+      --summaryTableType=<option>  [default: ascii, env: ALLURE_SUMMARY_TABLE_TYPE] Summary table format
+                                   <options: ascii|markdown>
+      --updatePr=<option>          [env: ALLURE_UPDATE_PR] Update PR with report URL (comment/description/actions)
+                                   <options: comment|description|actions>
+
+DESCRIPTION
+  Generate and upload allure report to cloud storage
+
+EXAMPLES
+  $ allure-report-publisher upload s3 --results-glob="path/to/allure-results" --bucket=my-bucket
+
+  $ allure-report-publisher upload gcs --results-glob="paths/to/**/allure-results" --bucket=my-bucket --prefix=my-project/prs
+
+  $ allure-report-publisher upload gitlab-artifacts --results-glob="paths/to/**/allure-results"
+
+  $ allure-report-publisher upload s3 --results-glob="path/to/allure-results" --bucket=my-bucket --update-pr=comment --summary=behaviors
+```
+
+_See code: [src/commands/upload/index.ts](https://github.com/andrcuns/allure-report-publisher/blob/v5.0.0-alpha.0/src/commands/upload/index.ts)_
+<!-- commandsstop -->
+
+## Docker
+
+To use cli via docker, run following command:
+
+```sh-session
+docker pull andrcuns/allure-report-publisher:latest
+```
+
+# Storage providers
+
+Multiple cloud storage providers are supported
+
+## AWS S3
+
+Requires environment variables `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` or credentials file `~/.aws/credentials`
+
+Additional configuration:
+
+- `AWS_REGION`: configure s3 region, default: `us-east-1`
+- `AWS_FORCE_PATH_STYLE`: when set to true, the bucket name is always left in the request URI and never moved to the host as a sub-domain, default: `false`
+- `AWS_ENDPOINT`: custom s3 endpoint when used with other s3 compatible storage
+
+## Google Cloud Storage
+
+Requires on of the following environment variables.
+
+credentials.json file location:
+
+- `STORAGE_CREDENTIALS`
+- `STORAGE_KEYFILE`
+- `GOOGLE_CLOUD_CREDENTIALS`
+- `GOOGLE_CLOUD_KEYFILE`
+- `GCLOUD_KEYFILE`
+
+credentials.json contents:
+
+- `GOOGLE_CLOUD_CREDENTIALS_JSON`
+- `STORAGE_CREDENTIALS_JSON`
+- `STORAGE_KEYFILE_JSON`
+- `GOOGLE_CLOUD_CREDENTIALS_JSON`
+- `GOOGLE_CLOUD_KEYFILE_JSON`
+- `GCLOUD_KEYFILE_JSON`
+
+## Gitlab Artifacts
+
+This storage provider is only supported for GitLab CI. Because GitLab does not expose public api for uploading artifacts, a job must be configured to upload the report as an artifact. Example:
+
+```yaml
+# .gitlab-ci.yml
+artifacts:
+  paths:
+    - allure-report
+```
+
+where `allure-report` is the directory containing the generated Allure report and can be overridden via `--output` option.
+
+Requires environment variable `GITLAB_AUTH_TOKEN` where token is a GitLab personal access token with `api` scope capable of downloading artifacts and retrieving job and pipeline information.
+
+This provider is meant to be used with [GitLab CI](#gitlab-ci).
+
+# CI
+
+`allure-report-publisher` will automatically detect if used in CI environment and add relevant executor info and history.
+
+Following CI providers are supported:
+
+- Github Actions
+- Gitlab CI
+
+## Pull requests
+
+It is possible to update pull requests with urls to published reports and execution summary.
+
+- `--update-pr=(comment|description|actions)`: post report urls in pr description, as a comment or step summary for github actions
+- `--summary=(behaviors|suites|packages|total)`: add execution summary table
+- `--summary-table-type=(ascii|markdown)`: use markdown or ascii table formatting
+- `--[no-]collapse-summary`: add summary in collapsable section
+
+Example:
+
+---
+
+`# Allure report`
+
+`allure-report-publisher` generated test report!
+
+**rspec**: ✅ [test report](https://storage.googleapis.com/allure-test-reports/allure-report-publisher/refs/heads/main/index.html) for [1b756f48](https://github.com/andrcuns/allure-report-publisher/commit/HEAD)
+
+```markdown
++--------------------------------------------------------+
+|                   total summary                        |
++-----------+--------+--------+---------+-------+--------+
+|           | passed | failed | skipped | flaky | result |
++-----------+--------+--------+---------+-------+--------+
+| Total     | 100    | 0      | 2       | 0     | ✅     |
++-----------+--------+--------+---------+-------+--------+
+```
+
+---
+
+## Github Actions
+
+Additional configuration is done via environment variables
+
+Authentication for PR updates:
+
+- `GITHUB_AUTH_TOKEN`: github auth token with api access
+
+Following environment variables can override default CI values:
+
+- `ALLURE_JOB_NAME`: overrides default `GITHUB_JOB` value which is used as name for report url section
+- `ALLURE_RUN_ID`: overrides default `GITHUB_RUN_ID` value which is used as name for the run number
+
+### allure-publish-action
+
+[allure-publish-action](https://github.com/marketplace/actions/allure-publish-action) can be used to easily run report publishing from any github actions job.
+
+## Gitlab CI
+
+Additional configuration is done via environment variables
+
+### Authentication
+
+Authentication for MR updates:
+
+- `GITLAB_AUTH_TOKEN`: gitlab access token with api access
+
+### CI values
+
+Following environment variables can override default CI values:
+
+- `ALLURE_JOB_NAME`: overrides default `CI_JOB_NAME` value which is used as name for report url section
+- `ALLURE_RUN_ID`: overrides default `CI_PIPELINE_ID` value which is used as name for the run number
+
+In case merge request triggers a downstream pipeline yet you want to update original merge request, overriding following environment variables might be useful:
+
+- `ALLURE_PROJECT_PATH`: overrides default `CI_PROJECT_PATH` value
+- `ALLURE_MERGE_REQUEST_IID`: overrides default `CI_MERGE_REQUEST_IID` value
+- `ALLURE_COMMIT_SHA`: overrides default `CI_MERGE_REQUEST_SOURCE_BRANCH_SHA` or `CI_COMMIT_SHA` values
+
+### Summary comment behavior
+
+If reporter is executed with options `--update-pr=comment` and `--unresolved-discussion-on-failure`, it's possible to additionally configure the unresolved discussion note:
+
+- `ALLURE_FAILURE_ALERT_COMMENT`: comment added to create unresolved discussion note, default: `There are some test failures that need attention`
+
+### CI/CD catalog resource
+
+[allure-report-publisher CI/CD catalog resource](https://gitlab.com/andrcuns/allure-report-publisher) can be used to easily integrate report publishing in to Gitlab CI pipelines.
+
+# Development
+
+Local development tool are handled by [mise](https://mise.jdx.dev/). After checking out the repo, run `mise install` to install necessary dev tools. Run `pnpm install` to install all node dependencies. To run tests, use `pnpm run test`. `bin/dev.js` allows to execute the cli directly from the source code without building it first.
+
+# Contributing
+
+Bug reports and pull requests are welcome on GitHub at <https://github.com/andrcuns/allure-report-publisher>. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/andrcuns/allure-report-publisher/blob/main/CODE_OF_CONDUCT.md).
+
+# License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+# Code of Conduct
+
+Everyone interacting in the allure-report-publisher project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/andrcuns/allure-report-publisher/blob/main/CODE_OF_CONDUCT.md).

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node --import tsx --no-warnings=ExperimentalWarning "%~dp0\dev" %*

package/bin/dev.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env -S node --import tsx --disable-warning=ExperimentalWarning
+
+import {execute} from '@oclif/core'
+
+await execute({development: true, dir: import.meta.url})

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import {execute} from '@oclif/core'
+
+await execute({dir: import.meta.url})

package/dist/commands/upload/index.d.ts

@@ -0,0 +1,31 @@
+import { Command } from '@oclif/core';
+export default class Upload extends Command {
+    static args: {
+        type: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        baseUrl: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        resultsGlob: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        bucket: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        prefix: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        config: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        reportName: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        ciReportTitle: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        summary: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        summaryTableType: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        updatePr: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        collapseSummary: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        color: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        copyLatest: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        flakyWarningStatus: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ignoreMissingResults: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        parallel: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private validateInputs;
+    private getAllureResults;
+}

package/dist/commands/upload/index.js

@@ -0,0 +1,198 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { getAllureConfig } from '../../lib/allure/config.js';
+import { ReportGenerator } from '../../lib/allure/report-generator.js';
+import { config } from '../../utils/config.js';
+import { getAllureResultsPaths } from '../../utils/glob.js';
+import { logger } from '../../utils/logger.js';
+import { spin } from '../../utils/spinner.js';
+import { getUploader } from '../../utils/uploader.js';
+export default class Upload extends Command {
+    static args = {
+        type: Args.string({
+            description: 'Cloud storage provider type',
+            options: ['s3', 'gcs', 'gitlab-artifacts'],
+            required: true,
+        }),
+    };
+    static description = 'Generate and upload allure report to cloud storage';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> s3 --results-glob="path/to/allure-results" --bucket=my-bucket',
+        '<%= config.bin %> <%= command.id %> gcs --results-glob="paths/to/**/allure-results" --bucket=my-bucket --prefix=my-project/prs',
+        '<%= config.bin %> <%= command.id %> gitlab-artifacts --results-glob="paths/to/**/allure-results"',
+        '<%= config.bin %> <%= command.id %> s3 --results-glob="path/to/allure-results" --bucket=my-bucket --update-pr=comment --summary=behaviors',
+    ];
+    static flags = {
+        baseUrl: Flags.string({
+            aliases: ['base-url'],
+            description: 'Custom base URL for report links',
+            env: 'ALLURE_BASE_URL',
+        }),
+        resultsGlob: Flags.string({
+            aliases: ['results-glob'],
+            char: 'r',
+            default: './**/allure-results',
+            description: 'Glob pattern for allure results directories',
+            env: 'ALLURE_RESULTS_GLOB',
+        }),
+        bucket: Flags.string({
+            char: 'b',
+            description: 'Cloud storage bucket name (required for s3/gcs)',
+            env: 'ALLURE_BUCKET',
+        }),
+        prefix: Flags.string({
+            char: 'p',
+            description: 'Prefix for report path in cloud storage (ignored for gitlab-artifacts)',
+            env: 'ALLURE_PREFIX',
+        }),
+        config: Flags.string({
+            char: 'c',
+            description: 'The path to allure config file (only .json or .yaml are supported)',
+            env: 'ALLURE_CONFIG_PATH',
+        }),
+        reportName: Flags.string({
+            aliases: ['report-name'],
+            description: 'Custom report name in Allure report (ignored with config-path)',
+            env: 'ALLURE_REPORT_NAME',
+        }),
+        ciReportTitle: Flags.string({
+            aliases: ['ci-report-title'],
+            default: 'Allure Report',
+            description: 'Title for PR comment/description section',
+            env: 'ALLURE_CI_REPORT_TITLE',
+        }),
+        summary: Flags.string({
+            default: 'total',
+            description: 'Add test summary table to PR',
+            env: 'ALLURE_SUMMARY',
+            options: ['behaviors', 'suites', 'packages', 'total'],
+        }),
+        summaryTableType: Flags.string({
+            aliases: ['summary-table-type'],
+            default: 'ascii',
+            description: 'Summary table format',
+            env: 'ALLURE_SUMMARY_TABLE_TYPE',
+            options: ['ascii', 'markdown'],
+        }),
+        updatePr: Flags.string({
+            aliases: ['update-pr'],
+            description: 'Update PR with report URL (comment/description/actions)',
+            env: 'ALLURE_UPDATE_PR',
+            options: ['comment', 'description', 'actions'],
+        }),
+        // Boolean flags
+        collapseSummary: Flags.boolean({
+            aliases: ['collapse-summary'],
+            default: false,
+            description: 'Create collapsible summary section in PR',
+            env: 'ALLURE_COLLAPSE_SUMMARY',
+        }),
+        color: Flags.boolean({
+            allowNo: true,
+            description: 'Force color output',
+            env: 'ALLURE_COLOR',
+        }),
+        copyLatest: Flags.boolean({
+            aliases: ['copy-latest'],
+            default: false,
+            description: 'Keep copy of latest run report at base prefix (ignored for gitlab-artifacts)',
+            env: 'ALLURE_COPY_LATEST',
+        }),
+        debug: Flags.boolean({
+            default: false,
+            description: 'Print debug log output',
+            env: 'ALLURE_DEBUG',
+        }),
+        flakyWarningStatus: Flags.boolean({
+            aliases: ['flaky-warning-status'],
+            default: false,
+            description: 'Mark run with ! status if flaky tests found',
+            env: 'ALLURE_FLAKY_WARNING_STATUS',
+        }),
+        ignoreMissingResults: Flags.boolean({
+            aliases: ['ignore-missing-results'],
+            default: false,
+            description: 'Ignore missing allure results',
+            env: 'ALLURE_IGNORE_MISSING_RESULTS',
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'Output directory for generated report (default: temp dir for cloud, "allure-report" for gitlab-artifacts)',
+            env: 'ALLURE_OUTPUT',
+        }),
+        parallel: Flags.integer({
+            default: 8,
+            description: 'Number of parallel threads for upload',
+            env: 'ALLURE_PARALLEL',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Upload);
+        const colorEnabled = flags.color ?? process.stdout.isTTY;
+        config.initialize({ color: colorEnabled, debug: flags.debug, parallel: flags.parallel });
+        try {
+            const storageType = args.type;
+            await this.validateInputs(storageType, flags);
+            logger.section('Generating allure report');
+            const resultPaths = await this.getAllureResults(flags.resultsGlob, flags.ignoreMissingResults);
+            if (resultPaths === undefined)
+                return;
+            const allureConfig = getAllureConfig(flags.config, flags.reportName);
+            const uploader = getUploader(storageType, {
+                baseUrl: flags.baseUrl,
+                bucket: flags.bucket,
+                copyLatest: flags.copyLatest,
+                parallel: flags.parallel,
+                prefix: flags.prefix,
+                output: await allureConfig.outputPath(),
+                historyPath: await allureConfig.historyPath(),
+                plugins: await allureConfig.plugins(),
+            });
+            const reportGenerator = new ReportGenerator(flags.resultsGlob, allureConfig, () => uploader.downloadHistory());
+            await reportGenerator.execute();
+            logger.section(`Uploading report to ${storageType}`);
+            await uploader.upload();
+            // TODO: Update PR if requested
+            if (flags.updatePr) {
+                logger.section('Updating PR/MR');
+                logger.info('PR update not yet implemented');
+            }
+        }
+        catch (error) {
+            logger.error(error.message);
+            this.exit(1);
+        }
+    }
+    async validateInputs(type, flags) {
+        if (type !== 'gitlab-artifacts' && !flags.bucket) {
+            throw new Error(`--bucket is required for storage type "${type}"\nOnly gitlab-artifacts does not require a bucket.`);
+        }
+        if (flags.baseUrl) {
+            try {
+                // eslint-disable-next-line no-new
+                new URL(flags.baseUrl);
+            }
+            catch {
+                throw new Error(`Invalid base URL: ${flags.baseUrl}\nBase URL must be a valid URL starting with http:// or https://`);
+            }
+        }
+        if (flags.parallel < 1) {
+            throw new Error(`Invalid parallel threads: ${flags.parallel}\nParallel threads must be >= 1`);
+        }
+        if (flags.config) {
+            const ext = path.extname(flags.config).toLowerCase();
+            const supportedExts = ['.json', '.yaml'];
+            if (!supportedExts.includes(ext)) {
+                throw new Error(`Unsupported config file format: ${ext}\nSupported formats are: ${supportedExts.join(', ')}`);
+            }
+            if (existsSync(flags.config) === false) {
+                throw new Error(`Config file not found at path: ${flags.config}`);
+            }
+        }
+    }
+    async getAllureResults(resultsGlob, ignoreMissingResults) {
+        const resultPaths = await spin(getAllureResultsPaths(resultsGlob, ignoreMissingResults), `scanning allure results directories`, { ignoreError: ignoreMissingResults });
+        return resultPaths;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/lib/allure/config.d.ts

@@ -0,0 +1,8 @@
+import { PluginName } from '../../types/index.js';
+export interface AllureConfig {
+    configPath(): string;
+    historyPath(): Promise<string>;
+    outputPath(): Promise<string>;
+    plugins(): Promise<PluginName[]>;
+}
+export declare function getAllureConfig(configPath?: string, reportName?: string): AllureConfig;

package/dist/lib/allure/config.js

@@ -0,0 +1,125 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import yaml from 'yaml';
+import { logger } from '../../utils/logger.js';
+import { spin } from '../../utils/spinner.js';
+const defaultReportBasePath = path.join(os.tmpdir(), 'allure-report-publisher');
+const defaultConfig = {
+    output: path.join(defaultReportBasePath, 'allure-report'),
+    historyPath: path.join(defaultReportBasePath, 'history.jsonl'),
+    appendHistory: true,
+    plugins: {
+        awesome: {
+            options: {
+                enabled: true,
+                singleFile: true,
+                reportName: 'Test Report',
+            },
+        },
+    },
+};
+class CustomConfig {
+    _configPath;
+    _parsedConfig = defaultConfig;
+    constructor(configPath) {
+        this._configPath = configPath;
+    }
+    configPath() {
+        return this._configPath;
+    }
+    async historyPath() {
+        const config = await this.customConfig();
+        const path = config.historyPath;
+        if (!path)
+            throw new Error('History path is not defined in the allure config');
+        return path;
+    }
+    async outputPath() {
+        const config = await this.customConfig();
+        return config.output || defaultConfig.output;
+    }
+    async plugins() {
+        const config = await this.customConfig();
+        const plugins = new Set(['allure2', 'awesome', 'classic', 'csv', 'dashboard']);
+        const configPlugins = config?.plugins || defaultConfig.plugins;
+        return Object.entries(configPlugins)
+            .filter(([pluginName, config]) => plugins.has(pluginName) && (config.enabled ?? true))
+            .map(([pluginName]) => pluginName);
+    }
+    async customConfig() {
+        if (this._parsedConfig === defaultConfig) {
+            this._parsedConfig = await spin(this.loadConfig(), 'loading custom allure config');
+        }
+        return this._parsedConfig;
+    }
+    async loadConfig() {
+        const ext = path.extname(this._configPath).toLowerCase();
+        switch (ext) {
+            case '.cjs':
+            case '.js':
+            case '.mjs': {
+                const fileUrl = pathToFileURL(this._configPath).href;
+                const module = await import(fileUrl);
+                // module.default will contain the object returned by defineConfig()
+                // allure loads parser with default config setup which will create error in the output
+                // plain object should be exported to avoid that
+                const defaultConfig = module.default;
+                if (defaultConfig === undefined) {
+                    throw new Error(`No default export found in the config file: ${this._configPath}`);
+                }
+                logger.debug(`Loaded JS config: ${JSON.stringify(defaultConfig, null, 2)}`);
+                return defaultConfig;
+            }
+            case '.json': {
+                const content = JSON.parse(readFileSync(this._configPath, 'utf8'));
+                logger.debug(`Loaded JSON config: ${JSON.stringify(content, null, 2)}`);
+                return content;
+            }
+            case '.yaml': {
+                const content = yaml.parse(readFileSync(this._configPath, 'utf8'));
+                logger.debug(`Loaded YAML config: ${JSON.stringify(content, null, 2)}`);
+                return content;
+            }
+            default: {
+                throw new Error(`Unsupported config file format: ${ext}`);
+            }
+        }
+    }
+}
+class DefaultConfig {
+    _configCreated;
+    _configPath;
+    reportName;
+    constructor(reportName) {
+        this._configCreated = false;
+        this._configPath = path.join(defaultReportBasePath, 'allurerc.json');
+        this.reportName = reportName;
+    }
+    configPath() {
+        if (this._configCreated)
+            return this._configPath;
+        mkdirSync(defaultReportBasePath, { recursive: true });
+        const config = { ...defaultConfig };
+        if (this.reportName)
+            config.plugins.awesome.options.reportName = this.reportName;
+        writeFileSync(this._configPath, JSON.stringify(config, null, 2));
+        this._configCreated = true;
+        return this._configPath;
+    }
+    async plugins() {
+        return ['awesome'];
+    }
+    async historyPath() {
+        return defaultConfig.historyPath;
+    }
+    async outputPath() {
+        return defaultConfig.output;
+    }
+}
+export function getAllureConfig(configPath, reportName) {
+    if (configPath)
+        return new CustomConfig(configPath);
+    return new DefaultConfig(reportName);
+}