pytest-allure-host 0.1.1__py3-none-any.whl

pytest_allure_host/__init__.py

@@ -0,0 +1,6 @@
+from .utils import PublishConfig, default_run_id  # re-export key types
+
+__all__ = [
+    "PublishConfig",
+    "default_run_id",
+]

pytest_allure_host/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

pytest_allure_host/cli.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import argparse
+import os
+
+from .config import load_effective_config
+from .publisher import plan_dry_run, preflight, publish
+from .utils import PublishConfig, default_run_id
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser("publish-allure")
+    p.add_argument("--config", help="Path to YAML config (optional)")
+    p.add_argument("--bucket")
+    p.add_argument("--prefix", default=None)
+    p.add_argument("--project")
+    p.add_argument("--branch", default=os.getenv("GIT_BRANCH", "main"))
+    p.add_argument(
+        "--run-id",
+        default=os.getenv("ALLURE_RUN_ID", default_run_id()),
+    )
+    p.add_argument("--cloudfront", default=os.getenv("ALLURE_CLOUDFRONT"))
+    p.add_argument("--results", default="allure-results")
+    p.add_argument("--report", default="allure-report")
+    p.add_argument("--ttl-days", type=int, default=None)
+    p.add_argument("--max-keep-runs", type=int, default=None)
+    p.add_argument(
+        "--s3-endpoint",
+        default=os.getenv("ALLURE_S3_ENDPOINT"),
+        help=("Custom S3 endpoint URL (e.g. http://localhost:4566 for LocalStack)"),
+    )
+    p.add_argument("--summary-json", default=None)
+    p.add_argument(
+        "--context-url",
+        default=os.getenv("ALLURE_CONTEXT_URL"),
+        help="Optional hyperlink giving change context (e.g. Jira ticket)",
+    )
+    p.add_argument("--dry-run", action="store_true", help="Plan only")
+    p.add_argument(
+        "--check",
+        action="store_true",
+        help="Run preflight checks (AWS, allure, inputs)",
+    )
+    return p.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    cli_overrides = {
+        "bucket": args.bucket,
+        "prefix": args.prefix,
+        "project": args.project,
+        "branch": args.branch,
+        "cloudfront": args.cloudfront,
+        "run_id": args.run_id,
+        "ttl_days": args.ttl_days,
+        "max_keep_runs": args.max_keep_runs,
+        "s3_endpoint": args.s3_endpoint,
+        "context_url": args.context_url,
+    }
+    effective = load_effective_config(cli_overrides, args.config)
+    missing = [k for k in ("bucket", "project") if not effective.get(k)]
+    if missing:
+        raise SystemExit(
+            f"Missing required config values: {', '.join(missing)}. Provide via CLI, env, or YAML."  # noqa: E501
+        )
+    cfg = PublishConfig(
+        bucket=effective["bucket"],
+        prefix=effective.get("prefix") or "reports",
+        project=effective["project"],
+        branch=effective.get("branch") or args.branch,
+        run_id=effective.get("run_id") or args.run_id,
+        cloudfront_domain=effective.get("cloudfront"),
+        ttl_days=effective.get("ttl_days"),
+        max_keep_runs=effective.get("max_keep_runs"),
+        s3_endpoint=effective.get("s3_endpoint"),
+        context_url=effective.get("context_url"),
+    )
+    if args.check:
+        checks = preflight(cfg)
+        print(checks)
+        if not all(checks.values()):
+            return 2
+    if args.dry_run:
+        plan = plan_dry_run(cfg)
+        print(plan)
+        if args.summary_json:
+            import json
+
+            with open(args.summary_json, "w", encoding="utf-8") as f:
+                json.dump(plan, f, indent=2)
+        return 0
+    out = publish(cfg)
+    print(out)
+    if args.summary_json:
+        import json
+
+        with open(args.summary_json, "w", encoding="utf-8") as f:
+            json.dump(out, f, indent=2)
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

pytest_allure_host/config.py

@@ -0,0 +1,141 @@
+"""Configuration loading utilities (YAML + env) for Allure hosting publisher.
+
+Precedence (highest first):
+1. Explicit CLI / pytest flag values
+2. Environment variables (ALLURE_BUCKET, ALLURE_PREFIX, ...)
+3. YAML file values (provided via --config or auto-discovered)
+4. Built-in defaults
+
+Auto-discovery order if --config not supplied:
+- ./allure-host.yml
+- ./allure-host.yaml
+- ./.allure-host.yml
+- ./.allure-host.yaml
+
+YAML schema (example):
+
+    bucket: my-reports-bucket
+    prefix: reports
+    project: payments
+    branch: main
+    ttl_days: 30
+    max_keep_runs: 20
+    cloudfront: https://reports.example.com
+    retention:
+      default_ttl_days: 30           # alias of ttl_days
+      max_keep_runs: 20              # duplicate path accepted
+
+Unknown keys are ignored (forward compatible).
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+CONFIG_FILENAMES = [
+    "allure-host.yml",
+    "allure-host.yaml",
+    ".allure-host.yml",
+    ".allure-host.yaml",
+    # Additional generic app config names people often use:
+    "application.yml",
+    "application.yaml",
+]
+
+ENV_MAP = {
+    "bucket": "ALLURE_BUCKET",
+    "prefix": "ALLURE_PREFIX",
+    "project": "ALLURE_PROJECT",
+    "branch": "ALLURE_BRANCH",
+    "cloudfront": "ALLURE_CLOUDFRONT",
+    "run_id": "ALLURE_RUN_ID",
+    "ttl_days": "ALLURE_TTL_DAYS",
+    "max_keep_runs": "ALLURE_MAX_KEEP_RUNS",
+    "s3_endpoint": "ALLURE_S3_ENDPOINT",
+    "context_url": "ALLURE_CONTEXT_URL",
+}
+
+
+@dataclass
+class LoadedConfig:
+    source_file: Path | None
+    data: dict[str, Any]
+
+
+def _read_yaml(path: Path) -> dict[str, Any]:
+    try:
+        with path.open("r", encoding="utf-8") as f:
+            content = yaml.safe_load(f) or {}
+        if not isinstance(content, dict):
+            return {}
+        return content
+    except FileNotFoundError:
+        return {}
+    except Exception:
+        # best effort - ignore malformed file
+        return {}
+
+
+def discover_yaml_config(explicit: str | None = None) -> LoadedConfig:
+    if explicit:
+        p = Path(explicit)
+        return LoadedConfig(
+            source_file=p if p.exists() else None,
+            data=_read_yaml(p),
+        )
+    for name in CONFIG_FILENAMES:
+        p = Path(name)
+        if p.exists():
+            return LoadedConfig(source_file=p, data=_read_yaml(p))
+    return LoadedConfig(source_file=None, data={})
+
+
+def merge_config(
+    yaml_cfg: dict[str, Any],
+    env: dict[str, str],
+    cli_overrides: dict[str, Any],
+) -> dict[str, Any]:
+    merged: dict[str, Any] = {}
+
+    # start with YAML
+    merged.update(yaml_cfg)
+
+    # retention nested block normalization
+    retention = yaml_cfg.get("retention")
+    if isinstance(retention, dict):
+        merged.setdefault("ttl_days", retention.get("default_ttl_days"))
+        merged.setdefault("max_keep_runs", retention.get("max_keep_runs"))
+
+    # env overrides
+    for key, env_var in ENV_MAP.items():
+        if env_var in env and env[env_var]:
+            merged[key] = env[env_var]
+
+    # explicit CLI overrides (ignore None only)
+    for k, v in cli_overrides.items():
+        if v is not None:
+            merged[k] = v
+
+    # type adjust
+    for int_field in ("ttl_days", "max_keep_runs"):
+        if int_field in merged and merged[int_field] not in (None, ""):
+            try:
+                merged[int_field] = int(merged[int_field])
+            except ValueError:
+                merged[int_field] = None
+
+    return merged
+
+
+def load_effective_config(
+    cli_args: dict[str, Any], explicit_config: str | None = None
+) -> dict[str, Any]:
+    loaded = discover_yaml_config(explicit_config)
+    data = merge_config(loaded.data, os.environ, cli_args)
+    data["_config_file"] = str(loaded.source_file) if loaded.source_file else None
+    return data

pytest_allure_host/plugin.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import json
+import os
+
+import pytest
+from botocore.exceptions import BotoCoreError, ClientError
+
+from .config import load_effective_config
+from .publisher import plan_dry_run, preflight, publish
+from .utils import PublishConfig, default_run_id
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    group = parser.getgroup("allure-host")
+    group.addoption("--allure-bucket", action="store", help="S3 bucket")
+    group.addoption("--allure-prefix", action="store", default="reports")
+    group.addoption("--allure-project", action="store", help="Project name")
+    group.addoption(
+        "--allure-branch",
+        action="store",
+        default=os.getenv("GIT_BRANCH", "main"),
+    )
+    group.addoption(
+        "--allure-cloudfront",
+        action="store",
+        default=os.getenv("ALLURE_CLOUDFRONT"),
+    )
+    group.addoption(
+        "--allure-run-id",
+        action="store",
+        default=os.getenv("ALLURE_RUN_ID", default_run_id()),
+    )
+    group.addoption("--allure-ttl-days", action="store", type=int, default=None)
+    group.addoption("--allure-max-keep-runs", action="store", type=int, default=None)
+    group.addoption("--allure-summary-json", action="store", default=None)
+    group.addoption("--allure-dry-run", action="store_true")
+    group.addoption("--allure-check", action="store_true")
+    group.addoption(
+        "--allure-context-url",
+        action="store",
+        default=os.getenv("ALLURE_CONTEXT_URL"),
+        help="Optional context hyperlink (e.g. Jira ticket)",
+    )
+    group.addoption(
+        "--allure-config",
+        action="store",
+        default=None,
+        help="YAML config file path (optional)",
+    )
+
+
+def pytest_terminal_summary(  # noqa: C901 - central orchestration, readable
+    terminalreporter: pytest.TerminalReporter, exitstatus: int
+) -> None:
+    config = terminalreporter.config
+    bucket = config.getoption("allure_bucket")
+    project = config.getoption("allure_project")
+    if not bucket or not project:
+        return
+    prefix = config.getoption("allure_prefix")
+    branch = config.getoption("allure_branch")
+    cloudfront = config.getoption("allure_cloudfront")
+    run_id = config.getoption("allure_run_id")
+    ttl_days = config.getoption("allure_ttl_days")
+    max_keep_runs = config.getoption("allure_max_keep_runs")
+    summary_json = config.getoption("allure_summary_json")
+    context_url = config.getoption("allure_context_url")
+
+    cli_overrides = {
+        "bucket": bucket,
+        "prefix": prefix,
+        "project": project,
+        "branch": branch,
+        "cloudfront": cloudfront,
+        "run_id": run_id,
+        "ttl_days": ttl_days,
+        "max_keep_runs": max_keep_runs,
+        "context_url": context_url,
+    }
+    effective = load_effective_config(cli_overrides, config.getoption("allure_config"))
+    # Minimal required
+    if not effective.get("bucket") or not effective.get("project"):
+        return
+    pub_cfg = PublishConfig(
+        bucket=effective["bucket"],
+        prefix=effective.get("prefix") or "reports",
+        project=effective["project"],
+        branch=effective.get("branch") or branch,
+        run_id=effective.get("run_id") or run_id,
+        cloudfront_domain=effective.get("cloudfront"),
+        ttl_days=effective.get("ttl_days"),
+        max_keep_runs=effective.get("max_keep_runs"),
+        context_url=effective.get("context_url"),
+    )
+
+    try:
+        if config.getoption("allure_check"):
+            checks = preflight(pub_cfg)
+            terminalreporter.write_line(f"Allure preflight: {checks}")
+            if summary_json:
+                with open(summary_json, "w", encoding="utf-8") as f:
+                    json.dump(checks, f, indent=2)
+            if not all(checks.values()):
+                return
+        if config.getoption("allure_dry_run"):
+            plan = plan_dry_run(pub_cfg)
+            terminalreporter.write_line(f"Allure plan: {plan}")
+            if summary_json:
+                with open(summary_json, "w", encoding="utf-8") as f:
+                    json.dump(plan, f, indent=2)
+            return
+        out = publish(pub_cfg)
+        terminalreporter.write_line(
+            f"Allure report published to:\n"
+            f"- run: {out.get('run_url') or pub_cfg.s3_run_prefix}\n"
+            f"- latest: {out.get('latest_url') or pub_cfg.s3_latest_prefix}"
+        )
+        if summary_json:
+            with open(summary_json, "w", encoding="utf-8") as f:
+                json.dump(out, f, indent=2)
+    except (ClientError, BotoCoreError, OSError, ValueError) as e:
+        # Known error categories: AWS client, IO, JSON/value issues
+        terminalreporter.write_line(f"Allure publish failed: {e}")
+    except Exception as e:  # noqa: BLE001
+        # Fallback catch-all to prevent pytest terminal crash; log generic
+        terminalreporter.write_line(f"Allure publish failed with unexpected error: {e}")