pytest-devant-cloud 0.1.0__tar.gz → 0.1.2__tar.gz

{pytest_devant_cloud-0.1.0 → pytest_devant_cloud-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-devant-cloud
-Version: 0.1.0
+Version: 0.1.2
 Summary: pytest plugin that streams runs, results, and step trees to Devant Cloud's /v1/runs API.
 Project-URL: Homepage, https://github.com/devant-net/devq-cloud/tree/main/packages/pytest-devant-cloud
 Project-URL: Repository, https://github.com/devant-net/devq-cloud

{pytest_devant_cloud-0.1.0 → pytest_devant_cloud-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pytest-devant-cloud"
-version = "0.1.0"
+version = "0.1.2"
 description = "pytest plugin that streams runs, results, and step trees to Devant Cloud's /v1/runs API."
 readme = "README.md"
 license = { file = "LICENSE" }

{pytest_devant_cloud-0.1.0 → pytest_devant_cloud-0.1.2}/src/pytest_devant_cloud/client.py

@@ -8,6 +8,7 @@ wire-level concerns (auth, retries, JSON encoding).
 
 from __future__ import annotations
 
+import os
 import time
 from dataclasses import dataclass
 from typing import Any
@@ -52,10 +53,14 @@ class DevqClient:
         # Re-use one Connection pool for the whole session — pytest can
         # easily emit hundreds of POSTs in a fast suite, and TCP setup
         # cost dwarfs the request itself otherwise.
+        # Content-Type intentionally NOT set here: httpx infers
+        # `application/json` from the `json=` kwarg used by _request(), and
+        # leaves multipart boundaries alone for `files=`-based uploads. A
+        # static client-level Content-Type would clobber the multipart
+        # boundary header on artifact uploads.
         self._http = httpx.Client(
             headers={
                 "Authorization": f"Bearer {api_token}",
-                "Content-Type": "application/json",
                 "Accept": "application/json",
             },
             timeout=timeout,
@@ -210,6 +215,36 @@ class DevqClient:
         body = resp.json()
         return body.get("results", [])
 
+    def upload_artifact(
+        self,
+        run_id: int,
+        result_id: int,
+        attempt_id: int,
+        *,
+        path: str,
+        name: str,
+        content_type: str,
+    ) -> None:
+        """Multipart POST a single file to the run/result/attempt's artifacts.
+
+        Mirrors @devant-net/reporter-core's `uploadArtifacts` wire shape:
+        one `file` part with the bytes, one `name` text part with the
+        display name shown in the Devant Cloud UI.
+        """
+        with open(path, "rb") as fh:
+            file_bytes = fh.read()
+        # Reuse the configured httpx client (auth header, base url, timeouts)
+        # but bypass `_request`'s JSON-only path.
+        resp = self._http.post(
+            f"{self.api_url}/v1/runs/{run_id}/results/{result_id}/attempts/{attempt_id}/artifacts",
+            files={"file": (os.path.basename(path), file_bytes, content_type)},
+            data={"name": name},
+        )
+        if resp.status_code >= 400:
+            raise RuntimeError(
+                f"[devant-reporter] artifact upload {resp.status_code}: {resp.text[:200]}"
+            )
+
     def submit_coverage(
         self,
         run_id: int,

{pytest_devant_cloud-0.1.0 → pytest_devant_cloud-0.1.2}/src/pytest_devant_cloud/plugin.py

@@ -9,7 +9,7 @@ Why these hooks (sourced from pytest 9.x reference docs):
                                   the run yet — we want to know the test
                                   count from collection first.
   * pytest_sessionstart         — `POST /v1/runs` once collection has happened
-                                  (unless DEVQ_RUN_ID is set; then we attach
+                                  (unless DEVANT_CLOUD_RUN_ID is set; then we attach
                                   to an externally-owned run).
   * pytest_runtest_makereport   — wrapper hook that stashes the phase report
                                   (setup/call/teardown) on the item, so the
@@ -82,26 +82,26 @@ def pytest_addoption(parser: pytest.Parser) -> None:
         "--devant-api-url",
         action="store",
         default=None,
-        help="Devant Cloud API URL (env: DEVQ_API_URL)",
+        help="Devant Cloud API URL (env: DEVANT_CLOUD_API_URL)",
     )
     group.addoption(
         "--devant-token",
         action="store",
         default=None,
-        help="Bearer token (env: DEVQ_TOKEN)",
+        help="Bearer token (env: DEVANT_CLOUD_TOKEN)",
     )
     group.addoption(
         "--devant-project-id",
         action="store",
         type=int,
         default=None,
-        help="Project id (env: DEVQ_PROJECT_ID)",
+        help="Project id (env: DEVANT_CLOUD_PROJECT_ID)",
     )
     group.addoption(
         "--devant-run-name",
         action="store",
         default=None,
-        help="Run display name (env: DEVQ_RUN_NAME)",
+        help="Run display name (env: DEVANT_CLOUD_RUN_NAME)",
     )
     group.addoption(
         "--devant-run-id",
@@ -109,7 +109,7 @@ def pytest_addoption(parser: pytest.Parser) -> None:
         type=int,
         default=None,
         help="Attach to an externally created run instead of creating one "
-        "(env: DEVQ_RUN_ID)",
+        "(env: DEVANT_CLOUD_RUN_ID)",
     )
     group.addoption(
         "--devant-disable",
@@ -119,13 +119,38 @@ def pytest_addoption(parser: pytest.Parser) -> None:
     )
 
 
-def _opt(config: pytest.Config, cli: str, env: str, default: Any) -> Any:
-    """CLI flag wins, then env var, then default."""
+_warned_legacy_env: set[str] = set()
+
+
+def _opt(
+    config: pytest.Config,
+    cli: str,
+    env: str,
+    default: Any,
+    *,
+    legacy_env: str | None = None,
+) -> Any:
+    """CLI flag wins, then canonical env var, then legacy env var (with a
+    one-time deprecation warning), then default.
+
+    The legacy_env parameter exists so historical DEVQ_* env vars keep working
+    while we transition to the DEVANT_CLOUD_* names. Will be dropped in a
+    future major release.
+    """
     v = config.getoption(cli, default=None)
     if v is not None:
         return v
     if env in os.environ and os.environ[env] != "":
         return os.environ[env]
+    if legacy_env and legacy_env in os.environ and os.environ[legacy_env] != "":
+        if legacy_env not in _warned_legacy_env:
+            _warned_legacy_env.add(legacy_env)
+            sys.stderr.write(
+                f'[devant] env var "{legacy_env}" is deprecated; please use '
+                f'"{env}" instead. Both work today; the legacy name will be '
+                "removed in a future major release.\n"
+            )
+        return os.environ[legacy_env]
     return default
 
 
@@ -145,15 +170,24 @@ def pytest_configure(config: pytest.Config) -> None:
         return
 
     api_url = _opt(
-        config, "--devant-api-url", "DEVQ_API_URL", "http://localhost:32124"
+        config,
+        "--devant-api-url",
+        "DEVANT_CLOUD_API_URL",
+        "http://localhost:32124",
+        legacy_env="DEVQ_API_URL",
     )
-    api_token_explicit = (
-        config.getoption("--devant-token", default=None)
-        or os.environ.get("DEVQ_TOKEN")
+    api_token_explicit = config.getoption("--devant-token", default=None) or _opt(
+        config, "--devant-token", "DEVANT_CLOUD_TOKEN", None, legacy_env="DEVQ_TOKEN"
     )
     api_token = api_token_explicit or "dev-admin-token"
 
-    project_raw = _opt(config, "--devant-project-id", "DEVQ_PROJECT_ID", 1)
+    project_raw = _opt(
+        config,
+        "--devant-project-id",
+        "DEVANT_CLOUD_PROJECT_ID",
+        1,
+        legacy_env="DEVQ_PROJECT_ID",
+    )
     try:
         project_id = int(project_raw)
     except (TypeError, ValueError):
@@ -161,8 +195,8 @@ def pytest_configure(config: pytest.Config) -> None:
     if project_id <= 0:
         # Don't blow up the test run — just refuse to enable the plugin.
         sys.stderr.write(
-            "[devant] DEVQ_PROJECT_ID must be a positive integer; reporter "
-            "disabled for this run\n"
+            "[devant] DEVANT_CLOUD_PROJECT_ID must be a positive integer; "
+            "reporter disabled for this run\n"
         )
         return
 
@@ -185,19 +219,26 @@ def pytest_configure(config: pytest.Config) -> None:
         )
         if not is_local:
             sys.stderr.write(
-                f'[devant] DEVQ_TOKEN is not set; falling back to "dev-admin-token" '
-                f"against {api_url}. Set DEVQ_TOKEN to a real CI token for "
-                "production use.\n"
+                f'[devant] DEVANT_CLOUD_TOKEN is not set; falling back to '
+                f'"dev-admin-token" against {api_url}. Set DEVANT_CLOUD_TOKEN '
+                "to a real CI token for production use.\n"
             )
 
     run_name = _opt(
         config,
         "--devant-run-name",
-        "DEVQ_RUN_NAME",
+        "DEVANT_CLOUD_RUN_NAME",
         f"pytest — {_dt.datetime.now(_dt.timezone.utc).isoformat(timespec='seconds')}",
+        legacy_env="DEVQ_RUN_NAME",
     )
 
-    external_run_raw = _opt(config, "--devant-run-id", "DEVQ_RUN_ID", None)
+    external_run_raw = _opt(
+        config,
+        "--devant-run-id",
+        "DEVANT_CLOUD_RUN_ID",
+        None,
+        legacy_env="DEVQ_RUN_ID",
+    )
     external_run_id: int | None = None
     if external_run_raw not in (None, ""):
         try:
@@ -461,4 +502,101 @@ def _submit_one(
             }
         ],
     }
-    state.client.submit_results(state.run_id, [submit_payload])
+    inserted = state.client.submit_results(state.run_id, [submit_payload])
+    _maybe_upload_playwright_artifacts(state, item, inserted)
+
+
+# ── Playwright (pytest-playwright) artifact integration ─────────────────────
+
+
+def _maybe_upload_playwright_artifacts(
+    state: _State,
+    item: pytest.Item,
+    inserted: list[dict[str, Any]],
+) -> None:
+    """If pytest-playwright wrote artifacts for this test, upload them.
+
+    pytest-playwright stores per-test artifacts at:
+        <--output dir>/<slugified-nodeid>/
+            trace.zip         (--tracing on / retain-on-failure)
+            video.webm        (--video on / retain-on-failure)
+            test-failed-N.png (--screenshot only-on-failure / on)
+
+    We compute the same path using pytest-playwright's own helpers (so the
+    slug formula stays in lockstep with upstream) and POST every file
+    inside as a multipart artifact attached to attempt 1.
+
+    Silent no-op when pytest-playwright isn't installed.
+    """
+    try:
+        from pytest_playwright.pytest_playwright import _truncate_file_name  # type: ignore
+        from slugify import slugify  # type: ignore
+    except ImportError:
+        return
+
+    if not inserted:
+        return
+    record = inserted[0]
+    result_id = record.get("result_id")
+    attempts = record.get("attempt_ids", [])
+    if not result_id or not attempts:
+        return
+    attempt_id = attempts[0].get("id")
+    if not attempt_id:
+        return
+
+    try:
+        output_root = item.session.config.getoption("--output", default="test-results")
+    except (ValueError, AttributeError):
+        return
+    from pathlib import Path
+
+    output_dir = Path(output_root).absolute() / _truncate_file_name(slugify(item.nodeid))
+    if not output_dir.is_dir():
+        return  # no artifacts captured for this test (passed cleanly, etc.)
+
+    for path in sorted(output_dir.iterdir()):
+        if not path.is_file():
+            continue
+        try:
+            content_type = _guess_content_type(path)
+            display = _artifact_display_name(path)
+            state.client.upload_artifact(
+                state.run_id or 0,
+                int(result_id),
+                int(attempt_id),
+                path=str(path),
+                name=display,
+                content_type=content_type,
+            )
+        except Exception as exc:  # noqa: BLE001
+            sys.stderr.write(
+                f'[devant] failed to upload "{path.name}" for "{item.nodeid}": {exc}\n'
+            )
+
+
+def _guess_content_type(path: "Path") -> str:  # noqa: F821  (Path imported above)
+    import mimetypes
+
+    suffix = path.suffix.lower()
+    if suffix == ".zip":
+        return "application/zip"
+    if suffix == ".webm":
+        return "video/webm"
+    if suffix == ".png":
+        return "image/png"
+    if suffix in (".jpg", ".jpeg"):
+        return "image/jpeg"
+    guessed, _ = mimetypes.guess_type(str(path))
+    return guessed or "application/octet-stream"
+
+
+def _artifact_display_name(path: "Path") -> str:  # noqa: F821
+    """UI-friendly artifact name. `trace*.zip` gets normalised to `trace.zip`
+    so the Devant Cloud UI's trace-viewer detection works regardless of
+    upstream filename quirks (Playwright writes `trace-1.zip` for multi-page
+    tests)."""
+    name = path.name
+    if path.suffix.lower() == ".zip" and "trace" in name.lower():
+        return "trace.zip"
+    return name