testrelic-pytest 0.1.1__py3-none-any.whl

testrelic_pytest/__init__.py

@@ -0,0 +1,35 @@
+"""TestRelic generic pytest reporter — pytest plugin and helpers."""
+
+from __future__ import annotations
+
+from testrelic_pytest._version import __version__
+from testrelic_pytest.config import (
+    CloudConfig,
+    PytestPluginConfig,
+    resolve_config,
+)
+from testrelic_pytest.schema import (
+    CapturedOutput,
+    CIMetadata,
+    FailureDiagnostic,
+    PhaseResult,
+    PytestResult,
+    PytestRunReport,
+    Status,
+    Summary,
+)
+
+__all__ = [
+    "CIMetadata",
+    "CapturedOutput",
+    "CloudConfig",
+    "FailureDiagnostic",
+    "PhaseResult",
+    "PytestPluginConfig",
+    "PytestResult",
+    "PytestRunReport",
+    "Status",
+    "Summary",
+    "__version__",
+    "resolve_config",
+]

testrelic_pytest/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

testrelic_pytest/ci_detector.py

@@ -0,0 +1,102 @@
+"""Detect CI provider and pull build metadata from environment variables."""
+
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+from testrelic_pytest.schema import CIMetadata
+
+
+def detect_ci() -> Optional[CIMetadata]:
+    """Return a populated `CIMetadata` if we recognise the CI provider."""
+    env = os.environ
+
+    if env.get("GITHUB_ACTIONS") == "true":
+        return CIMetadata(
+            provider="github-actions",
+            buildId=env.get("GITHUB_RUN_ID"),
+            commitSha=env.get("GITHUB_SHA"),
+            branch=env.get("GITHUB_REF_NAME"),
+            prNumber=_extract_pr_number(env.get("GITHUB_REF")),
+            workflow=env.get("GITHUB_WORKFLOW"),
+            runUrl=_github_run_url(dict(env)),
+        )
+
+    if env.get("GITLAB_CI") == "true":
+        return CIMetadata(
+            provider="gitlab-ci",
+            buildId=env.get("CI_PIPELINE_ID"),
+            commitSha=env.get("CI_COMMIT_SHA"),
+            branch=env.get("CI_COMMIT_REF_NAME"),
+            prNumber=env.get("CI_MERGE_REQUEST_IID"),
+            workflow=env.get("CI_JOB_NAME"),
+            runUrl=env.get("CI_PIPELINE_URL"),
+        )
+
+    if env.get("JENKINS_URL"):
+        return CIMetadata(
+            provider="jenkins",
+            buildId=env.get("BUILD_ID") or env.get("BUILD_NUMBER"),
+            commitSha=env.get("GIT_COMMIT"),
+            branch=env.get("GIT_BRANCH"),
+            workflow=env.get("JOB_NAME"),
+            runUrl=env.get("BUILD_URL"),
+        )
+
+    if env.get("CIRCLECI") == "true":
+        return CIMetadata(
+            provider="circleci",
+            buildId=env.get("CIRCLE_BUILD_NUM"),
+            commitSha=env.get("CIRCLE_SHA1"),
+            branch=env.get("CIRCLE_BRANCH"),
+            prNumber=_pr_from_url(env.get("CIRCLE_PULL_REQUEST")),
+            workflow=env.get("CIRCLE_JOB"),
+            runUrl=env.get("CIRCLE_BUILD_URL"),
+        )
+
+    if env.get("BITBUCKET_PIPELINE_UUID"):
+        return CIMetadata(
+            provider="bitbucket-pipelines",
+            buildId=env.get("BITBUCKET_BUILD_NUMBER"),
+            commitSha=env.get("BITBUCKET_COMMIT"),
+            branch=env.get("BITBUCKET_BRANCH"),
+            prNumber=env.get("BITBUCKET_PR_ID"),
+            workflow=env.get("BITBUCKET_PIPELINE_UUID"),
+            runUrl=_bitbucket_run_url(dict(env)),
+        )
+
+    return None
+
+
+def _extract_pr_number(ref: Optional[str]) -> Optional[str]:
+    if not ref:
+        return None
+    parts = ref.split("/")
+    if len(parts) >= 3 and parts[1] == "pull":
+        return parts[2]
+    return None
+
+
+def _github_run_url(env: dict[str, str]) -> Optional[str]:
+    server = env.get("GITHUB_SERVER_URL")
+    repo = env.get("GITHUB_REPOSITORY")
+    run = env.get("GITHUB_RUN_ID")
+    if server and repo and run:
+        return f"{server}/{repo}/actions/runs/{run}"
+    return None
+
+
+def _bitbucket_run_url(env: dict[str, str]) -> Optional[str]:
+    workspace = env.get("BITBUCKET_WORKSPACE")
+    repo = env.get("BITBUCKET_REPO_SLUG")
+    build = env.get("BITBUCKET_BUILD_NUMBER")
+    if workspace and repo and build:
+        return f"https://bitbucket.org/{workspace}/{repo}/pipelines/results/{build}"
+    return None
+
+
+def _pr_from_url(url: Optional[str]) -> Optional[str]:
+    if not url:
+        return None
+    return url.rstrip("/").split("/")[-1] or None

testrelic_pytest/cli.py

@@ -0,0 +1,59 @@
+"""`testrelic-pytest` CLI."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from testrelic_pytest._version import __version__
+
+app = typer.Typer(
+    name="testrelic-pytest",
+    help="TestRelic generic pytest reporter CLI",
+    add_completion=False,
+)
+
+
+@app.command()
+def version() -> None:
+    """Print the package version."""
+    typer.echo(__version__)
+
+
+@app.command(name="drain")
+def drain(
+    queue_dir: Optional[Path] = typer.Option(
+        None,
+        "--queue-dir",
+        help="Override the queue directory. Defaults to .testrelic/queue/.",
+    ),
+) -> None:
+    """Retry queued failed uploads."""
+    from testrelic_pytest.cloud.queue import drain_queue
+
+    counts = drain_queue(queue_dir)
+    typer.echo(json.dumps(counts, indent=2))
+
+
+@app.command()
+def status(
+    queue_dir: Optional[Path] = typer.Option(
+        None,
+        "--queue-dir",
+        help="Queue directory to inspect. Defaults to .testrelic/queue/.",
+    ),
+) -> None:
+    """Show how many uploads are pending replay."""
+    target = Path(queue_dir) if queue_dir else Path(".testrelic") / "queue"
+    if not target.exists():
+        typer.echo(json.dumps({"queued": 0, "queue_dir": str(target)}, indent=2))
+        return
+    queued = len(list(target.glob("*.json")))
+    typer.echo(json.dumps({"queued": queued, "queue_dir": str(target)}, indent=2))
+
+
+if __name__ == "__main__":
+    app()

testrelic_pytest/cloud/__init__.py

@@ -0,0 +1,64 @@
+"""Cloud upload package — session/auth lifecycle, request layer, queue."""
+
+from __future__ import annotations
+
+from testrelic_pytest.cloud.artifact import (
+    ArtifactType,
+    ArtifactUploadRequest,
+    ArtifactUploadResult,
+    upload_artifact,
+    upload_artifacts,
+)
+from testrelic_pytest.cloud.auth import (
+    AuthError,
+    RepoResolveResult,
+    TokenExchangeResult,
+    TokenRefreshResult,
+    enforce_https,
+    exchange_token,
+    health_check,
+    is_auth_error,
+    refresh_access_token,
+    resolve_repo,
+)
+from testrelic_pytest.cloud.client import CloudClient
+from testrelic_pytest.cloud.queue import drain_queue, enqueue
+from testrelic_pytest.cloud.upload import (
+    RealtimeInitResult,
+    UploadFailure,
+    UploadResult,
+    build_batch_payload,
+    finalize_run,
+    init_realtime_run,
+    upload_batch_run,
+    upload_test_result,
+)
+
+__all__ = [
+    "ArtifactType",
+    "ArtifactUploadRequest",
+    "ArtifactUploadResult",
+    "AuthError",
+    "CloudClient",
+    "RealtimeInitResult",
+    "RepoResolveResult",
+    "TokenExchangeResult",
+    "TokenRefreshResult",
+    "UploadFailure",
+    "UploadResult",
+    "build_batch_payload",
+    "drain_queue",
+    "enforce_https",
+    "enqueue",
+    "exchange_token",
+    "finalize_run",
+    "health_check",
+    "init_realtime_run",
+    "is_auth_error",
+    "refresh_access_token",
+    "resolve_repo",
+    "upload_artifact",
+    "upload_artifacts",
+    "upload_batch_run",
+    "upload_test_result",
+]

testrelic_pytest/cloud/artifact.py

@@ -0,0 +1,260 @@
+"""Binary artifact upload via presigned S3 PUT URLs.
+
+Wire protocol verified against cloud-platform-app:
+
+    POST /api/v1/artifacts/upload-url   -> { artifactId, uploadUrl, storageKey }
+    PUT  {uploadUrl}                    -> S3 PUT with binary body
+    POST /api/v1/artifacts/confirm      -> { artifactId }
+
+Concurrency-bounded by a ThreadPoolExecutor (5 workers). Never raises — returns
+structured results.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal, Optional
+
+import httpx
+
+logger = logging.getLogger("testrelic")
+
+ArtifactType = Literal["screenshot", "video", "trace", "other"]
+
+UPLOAD_CONCURRENCY = 5
+RETRY_DELAYS_SECONDS = (1.0, 3.0, 9.0)
+MAX_RETRIES = 3
+
+_CONTENT_TYPE_MAP: dict[str, str] = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".webm": "video/webm",
+    ".mp4": "video/mp4",
+    ".zip": "application/zip",
+    ".log": "text/plain",
+    ".txt": "text/plain",
+}
+
+
+@dataclass(frozen=True)
+class ArtifactUploadRequest:
+    file_path: Path
+    run_id: str
+    test_id: str
+    type: ArtifactType
+
+
+@dataclass(frozen=True)
+class ArtifactUploadResult:
+    success: bool
+    storage_key: Optional[str]
+    artifact_id: Optional[str]
+    error: Optional[str]
+
+
+def _content_type_for(path: Path) -> str:
+    return _CONTENT_TYPE_MAP.get(path.suffix.lower(), "application/octet-stream")
+
+
+def _file_size(path: Path) -> int:
+    try:
+        return path.stat().st_size
+    except OSError:
+        return 0
+
+
+def _request_upload_url(
+    endpoint: str,
+    access_token: str,
+    request: ArtifactUploadRequest,
+    size_bytes: int,
+    content_type: str,
+    *,
+    timeout_seconds: float,
+) -> Optional[dict[str, str]]:
+    url = f"{endpoint.rstrip('/')}/artifacts/upload-url"
+    body = {
+        "runId": request.run_id,
+        "testId": request.test_id,
+        "fileName": request.file_path.name,
+        "contentType": content_type,
+        "type": request.type,
+        "sizeBytes": size_bytes,
+    }
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {access_token}",
+    }
+    for attempt in range(MAX_RETRIES):
+        try:
+            with httpx.Client(timeout=timeout_seconds) as client:
+                response = client.post(url, json=body, headers=headers)
+        except httpx.HTTPError:
+            if attempt < MAX_RETRIES - 1:
+                time.sleep(RETRY_DELAYS_SECONDS[attempt])
+                continue
+            return None
+
+        if 200 <= response.status_code < 300:
+            try:
+                data = response.json()
+            except ValueError:
+                return None
+            return {
+                "artifactId": data["artifactId"],
+                "uploadUrl": data["uploadUrl"],
+                "storageKey": data["storageKey"],
+            }
+        if response.status_code >= 500 and attempt < MAX_RETRIES - 1:
+            time.sleep(RETRY_DELAYS_SECONDS[attempt])
+            continue
+        return None
+    return None
+
+
+def _put_file(
+    presigned_url: str,
+    file_path: Path,
+    content_type: str,
+    size_bytes: int,
+    *,
+    timeout_seconds: float,
+) -> bool:
+    headers = {
+        "Content-Type": content_type,
+        "Content-Length": str(size_bytes),
+    }
+    for attempt in range(MAX_RETRIES):
+        try:
+            with file_path.open("rb") as fh:
+                with httpx.Client(timeout=timeout_seconds) as client:
+                    response = client.put(presigned_url, content=fh.read(), headers=headers)
+        except (httpx.HTTPError, OSError):
+            if attempt < MAX_RETRIES - 1:
+                time.sleep(RETRY_DELAYS_SECONDS[attempt])
+                continue
+            return False
+        if 200 <= response.status_code < 300:
+            return True
+        if response.status_code >= 500 and attempt < MAX_RETRIES - 1:
+            time.sleep(RETRY_DELAYS_SECONDS[attempt])
+            continue
+        return False
+    return False
+
+
+def _confirm_upload(
+    endpoint: str,
+    access_token: str,
+    artifact_id: str,
+    *,
+    timeout_seconds: float,
+) -> bool:
+    url = f"{endpoint.rstrip('/')}/artifacts/confirm"
+    try:
+        with httpx.Client(timeout=timeout_seconds) as client:
+            response = client.post(
+                url,
+                json={"artifactId": artifact_id},
+                headers={
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {access_token}",
+                },
+            )
+        return 200 <= response.status_code < 300
+    except httpx.HTTPError:
+        return False
+
+
+def upload_artifact(
+    endpoint: str,
+    access_token: str,
+    request: ArtifactUploadRequest,
+    *,
+    max_size_mb: int = 50,
+    timeout_seconds: float = 60.0,
+) -> ArtifactUploadResult:
+    """Upload one artifact end-to-end. Never raises."""
+    size_bytes = _file_size(request.file_path)
+    if size_bytes == 0:
+        return ArtifactUploadResult(False, None, None, "file_not_found_or_empty")
+    if size_bytes > max_size_mb * 1024 * 1024:
+        return ArtifactUploadResult(False, None, None, "file_too_large")
+
+    content_type = _content_type_for(request.file_path)
+
+    url_result = _request_upload_url(
+        endpoint,
+        access_token,
+        request,
+        size_bytes,
+        content_type,
+        timeout_seconds=timeout_seconds,
+    )
+    if url_result is None:
+        return ArtifactUploadResult(False, None, None, "upload_url_request_failed")
+
+    uploaded = _put_file(
+        url_result["uploadUrl"],
+        request.file_path,
+        content_type,
+        size_bytes,
+        timeout_seconds=timeout_seconds,
+    )
+    if not uploaded:
+        return ArtifactUploadResult(
+            False, url_result["storageKey"], url_result["artifactId"], "presigned_put_failed"
+        )
+
+    confirmed = _confirm_upload(
+        endpoint, access_token, url_result["artifactId"], timeout_seconds=timeout_seconds
+    )
+    return ArtifactUploadResult(
+        success=confirmed,
+        storage_key=url_result["storageKey"],
+        artifact_id=url_result["artifactId"],
+        error=None if confirmed else "confirm_failed",
+    )
+
+
+def upload_artifacts(
+    endpoint: str,
+    access_token: str,
+    requests: list[ArtifactUploadRequest],
+    *,
+    max_size_mb: int = 50,
+    timeout_seconds: float = 60.0,
+) -> dict[Path, ArtifactUploadResult]:
+    """Upload multiple artifacts with bounded concurrency."""
+    results: dict[Path, ArtifactUploadResult] = {}
+    if not requests:
+        return results
+
+    with ThreadPoolExecutor(max_workers=UPLOAD_CONCURRENCY) as pool:
+        futures = {
+            pool.submit(
+                upload_artifact,
+                endpoint,
+                access_token,
+                req,
+                max_size_mb=max_size_mb,
+                timeout_seconds=timeout_seconds,
+            ): req
+            for req in requests
+        }
+        for future in as_completed(futures):
+            req = futures[future]
+            try:
+                results[req.file_path] = future.result()
+            except Exception as exc:
+                logger.debug(
+                    "[testrelic] artifact upload exception for %s: %s", req.file_path, exc
+                )
+                results[req.file_path] = ArtifactUploadResult(False, None, None, str(exc))
+    return results