charisma-cli 0.2.0__tar.gz → 0.2.2__tar.gz

{charisma_cli-0.2.0 → charisma_cli-0.2.2}/.gitignore

@@ -55,7 +55,8 @@ dist/
 
 # Python cache
 *.pyc
-*/__pycache__/
+*.pyc.*
+**/__pycache__/
 
 # Python virtual environments
 .venv/
@@ -133,3 +134,5 @@ backend/coverage.json
 */__pycache__/*
 allure-results/*
 allure-results-live/
+*tasks.meta.json
+*.code-workspace

{charisma_cli-0.2.0 → charisma_cli-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: charisma-cli
-Version: 0.2.0
+Version: 0.2.2
 Summary: CLI tool that watches allure-results and streams test results + attachments to Charisma.
 Author: Charisma Team
 License-Expression: MIT

{charisma_cli-0.2.0 → charisma_cli-0.2.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "charisma-cli"
-version = "0.2.0"
+version = "0.2.2"
 description = "CLI tool that watches allure-results and streams test results + attachments to Charisma."
 readme = "README.md"
 license = "MIT"

{charisma_cli-0.2.0 → charisma_cli-0.2.2}/src/charisma_cli/__init__.py

@@ -1,3 +1,3 @@
 """charisma-cli: Stream allure results to Charisma in real time."""
 
-__version__ = "0.1.6"
+__version__ = "0.2.2"

{charisma_cli-0.2.0 → charisma_cli-0.2.2}/src/charisma_cli/models.py

@@ -3,6 +3,33 @@
 from dataclasses import dataclass, field
 from enum import IntEnum
 from pathlib import Path
+from typing import Any
+from uuid import NAMESPACE_URL, uuid5
+
+
+def backend_result_id(launch_id: str, test_id: str) -> str:
+    """Derive the result identity the Charisma backend stores and validates against.
+
+    The backend computes ``test_results.id`` as
+    ``uuid5(NAMESPACE_URL, f"{launch_id}/{test_id}")`` (see backend
+    ``models/testresults.py`` ``to_canonical``). Attachment uploads are validated
+    against that stored id, so the CLI MUST send the same value as ``resultId`` —
+    not the raw Allure ``uuid``, which the backend discards. This function is the
+    single CLI-side mirror of that contract; keep the namespace, separator, and
+    field order byte-identical to the backend.
+
+    Args:
+        launch_id: The open launch UUID returned by the backend.
+        test_id: The result's test identity — the SAME value the CLI sends as
+            ``test_id`` in the results batch. This is the Allure ``historyId``,
+            falling back to ``fullName`` when ``historyId`` is absent (see
+            ``parser.parse_result_file``). Matching the backend requires only
+            that both sides key off this same value, whichever it is.
+
+    Returns:
+        The deterministic result id string matching the backend's stored id.
+    """
+    return str(uuid5(NAMESPACE_URL, f"{launch_id}/{test_id}"))
 
 
 class FileCategory(IntEnum):
@@ -52,6 +79,28 @@ class AttachmentRef:
     mime_type: str  # content-type
     result_uuid: str  # owning result UUID
 
+    @classmethod
+    def from_allure(cls, attachment: dict[str, Any], result_uuid: str) -> "AttachmentRef | None":
+        """Build an AttachmentRef from a single Allure attachment entry.
+
+        Args:
+            attachment: An Allure attachment dict (``source``, optional ``name``
+                and ``type``).
+            result_uuid: The UUID of the owning result.
+
+        Returns:
+            An AttachmentRef, or None if the attachment has no usable ``source``.
+        """
+        source = attachment.get("source")
+        if not source:
+            return None
+        return cls(
+            source=source,
+            name=attachment.get("name", source),
+            mime_type=attachment.get("type", "application/octet-stream"),
+            result_uuid=result_uuid,
+        )
+
 
 @dataclass
 class ContainerData:

{charisma_cli-0.2.0 → charisma_cli-0.2.2}/src/charisma_cli/parser.py

@@ -7,6 +7,7 @@ for streaming to the Charisma ingestion API.
 import json
 import logging
 from pathlib import Path
+from typing import Any
 
 from charisma_cli.models import AttachmentRef, CharismaResult, ContainerData
 
@@ -185,31 +186,86 @@ def parse_environment_properties(path: Path) -> dict[str, str]:
     return variables
 
 
-def extract_attachment_refs(result_data: dict, result_uuid: str) -> list[AttachmentRef]:
+def _collect_step_attachments(steps: list[dict[str, Any]], result_uuid: str) -> list[AttachmentRef]:
+    """Recursively collect attachment refs from a list of Allure steps.
+
+    Allure nests attachments inside steps, and steps inside steps. A single
+    ``result_data["attachments"]`` read only sees attachments added directly to
+    the test body — the minority case. Screenshots and logs captured inside a
+    step (the common case) live in ``step["attachments"]`` at arbitrary depth.
+
+    Args:
+        steps: A list of Allure step dicts (may be empty or contain nested steps).
+        result_uuid: The UUID of the owning result, applied to every ref.
+
+    Returns:
+        Flat list of AttachmentRef for attachments found at every step depth.
+    """
+    refs: list[AttachmentRef] = []
+    for step in steps:
+        if not isinstance(step, dict):
+            continue
+        for attachment in step.get("attachments") or []:
+            ref = AttachmentRef.from_allure(attachment, result_uuid)
+            if ref is not None:
+                refs.append(ref)
+        refs.extend(_collect_step_attachments(step.get("steps") or [], result_uuid))
+    return refs
+
+
+def extract_attachment_refs(result_data: dict[str, Any], result_uuid: str) -> list[AttachmentRef]:
     """Extract attachment references from an Allure result data dict.
 
+    Collects attachments from the result's top-level ``attachments`` array AND
+    from every step (recursively through nested sub-steps), since Allure stores
+    most attachments inside steps rather than at the top level.
+
     Args:
         result_data: The raw parsed Allure result JSON dict.
         result_uuid: The UUID of the owning result (passed as argument,
             not taken from result_data).
 
     Returns:
-        List of AttachmentRef objects for each attachment in the result.
+        List of AttachmentRef objects for each attachment in the result,
+        including those nested inside steps.
     """
-    attachments = result_data.get("attachments")
-    if not attachments:
+    refs: list[AttachmentRef] = []
+    for attachment in result_data.get("attachments") or []:
+        ref = AttachmentRef.from_allure(attachment, result_uuid)
+        if ref is not None:
+            refs.append(ref)
+
+    refs.extend(_collect_step_attachments(result_data.get("steps") or [], result_uuid))
+    return refs
+
+
+def extract_container_attachment_refs(container: ContainerData) -> list[AttachmentRef]:
+    """Extract fixture attachment references from an Allure container.
+
+    Setup/teardown attachments (logs and screenshots captured in fixtures) live
+    in the container's ``befores``/``afters`` fixture steps, which nest ``steps``
+    and ``attachments`` just like result steps. These attachments belong to the
+    container's child results; without this extraction they are never registered
+    and every fixture attachment is skipped on upload.
+
+    A container may own multiple children (suite/class/session-scoped fixtures
+    run once for many tests). A fixture attachment applies to every test the
+    fixture served, so each attachment is bound to ALL of the container's
+    children — one AttachmentRef per (attachment, child) pair. Containers with
+    no children cannot bind their attachments and yield an empty list.
+
+    Args:
+        container: The parsed container holding fixture steps and child UUIDs.
+
+    Returns:
+        List of AttachmentRef for fixture attachments, one per child result.
+        Empty if there are no children.
+    """
+    if not container.children:
         return []
 
+    fixture_steps = list(container.befores) + list(container.afters)
     refs: list[AttachmentRef] = []
-    for attachment in attachments:
-        source = attachment["source"]
-        refs.append(
-            AttachmentRef(
-                source=source,
-                name=attachment.get("name", source),
-                mime_type=attachment.get("type", "application/octet-stream"),
-                result_uuid=result_uuid,
-            )
-        )
-
+    for child_uuid in container.children:
+        refs.extend(_collect_step_attachments(fixture_steps, child_uuid))
     return refs

{charisma_cli-0.2.0 → charisma_cli-0.2.2}/src/charisma_cli/uploader.py

@@ -12,12 +12,19 @@ import httpx
 
 from charisma_cli.config import Config
 from charisma_cli.models import (
+    AttachmentRef,
     ContainerData,
     FileCategory,
     FileEvent,
     UploadSummary,
+    backend_result_id,
+)
+from charisma_cli.parser import (
+    extract_attachment_refs,
+    extract_container_attachment_refs,
+    parse_container_file,
+    parse_result_file,
 )
-from charisma_cli.parser import extract_attachment_refs, parse_container_file, parse_result_file
 from charisma_cli.retry import MAX_RETRIES, RETRYABLE_STATUS_CODES, exponential_backoff
 
 logger = logging.getLogger(__name__)
@@ -68,8 +75,22 @@ class Uploader:
         self._batch_start: float = 0.0
         self._pending_containers: list[ContainerData] = []
         self._known_result_uuids: set[str] = set()
-        # Map source filename → result_uuid for attachment uploads
+        # Map source filename → owning result's Allure uuid (join key from
+        # Allure's own structure: results own attachments and have a uuid;
+        # containers reference their children by uuid).
         self._attachment_result_map: dict[str, str] = {}
+        # Map Allure result uuid → historyId. The backend keys stored results by
+        # uuid5(launch_id/historyId), NOT the Allure uuid, so an attachment's
+        # owning uuid must be translated to its historyId to compute the
+        # resultId the backend will accept. Populated as result files are parsed.
+        self._result_uuid_to_history: dict[str, str] = {}
+        # Attachments dequeued before their owning result/container was seen.
+        # In watch mode the PriorityQueue orders items co-present at dequeue time
+        # but gives no global temporal guarantee: an attachment can be processed
+        # before the result that registers its source→uuid mapping. These are
+        # held here and retried as mappings arrive; unresolved ones are counted
+        # as skipped at flush time.
+        self._pending_attachments: list[Path] = []
 
     @property
     def summary(self) -> UploadSummary:
@@ -315,6 +336,13 @@ class Uploader:
         # Track UUID for container association
         if result.uuid:
             self._known_result_uuids.add(result.uuid)
+            # Record uuid → historyId so attachments (which resolve to their
+            # owning Allure uuid) can be uploaded with the historyId-based id the
+            # backend actually stores. A newly-learned mapping may unblock
+            # attachments deferred because their owner's historyId wasn't known.
+            if result.testId:
+                self._result_uuid_to_history[result.uuid] = result.testId
+                self._retry_pending_attachments()
 
         # Build API payload (snake_case wire format — shared TestResultInput contract)
         payload: dict[str, Any] = {
@@ -396,58 +424,191 @@ class Uploader:
 
         # Extract attachment refs and register them for upload with correct result_uuid
         try:
-            refs = extract_attachment_refs(raw_data, result.uuid or "")
-            for ref in refs:
-                # Register source → result_uuid mapping so _handle_attachment knows the owner
-                self._attachment_result_map[ref.source] = ref.result_uuid
+            self._register_attachment_refs(extract_attachment_refs(raw_data, result.uuid or ""))
         except Exception:
             logger.debug("Failed to extract attachment refs from %s", path, exc_info=True)
 
     def _handle_container(self, path: Path) -> None:
-        """Parse a container file and buffer for deferred association."""
+        """Parse a container file and buffer for deferred association.
+
+        Also registers any fixture attachments (setup/teardown logs and
+        screenshots nested in befores/afters) so they upload with the correct
+        owning result. Without this, fixture attachments have no source→result
+        mapping and are skipped.
+        """
         container = parse_container_file(path)
         if container is None:
             return
 
+        try:
+            self._register_attachment_refs(extract_container_attachment_refs(container))
+        except Exception:
+            logger.debug("Failed to extract fixture attachment refs from %s", path, exc_info=True)
+
         container.received_at = time.monotonic()
         self._pending_containers.append(container)
         self._try_associate_containers()
 
+    def _register_attachment_refs(self, refs: list[AttachmentRef]) -> None:
+        """Register source→result_uuid mappings so _handle_attachment finds owners.
+
+        Thread affinity: ``_attachment_result_map`` is written here (from both
+        _handle_result and _handle_container) and read by _handle_attachment.
+        All three run on the single consumer thread (_run), so no lock is needed;
+        this single-consumer invariant is what keeps the map consistent.
+        """
+        if not refs:
+            return
+        for ref in refs:
+            self._attachment_result_map[ref.source] = ref.result_uuid
+        # A newly-registered mapping may unblock attachments that were dequeued
+        # before their owning result/container arrived (watch-mode ordering).
+        self._retry_pending_attachments()
+
     def _handle_attachment(self, path: Path) -> None:
-        """Upload an attachment file to the Charisma attachment API."""
+        """Upload an attachment, or defer it if its owning result isn't known yet.
+
+        The owning result/container may not have been processed at the moment
+        this attachment is dequeued (watch mode streams files in arrival order,
+        not owner-first). When the mapping is missing, the attachment is buffered
+        in ``_pending_attachments`` and retried once a mapping arrives, rather
+        than being immediately counted as skipped.
+        """
         if not self._launch_id or not path.exists():
             self._summary.attachments_skipped += 1
             return
 
-        # Look up the result_uuid for this attachment
-        result_uuid = self._attachment_result_map.get(path.name, "")
+        history_id = self._resolve_history_id(path.name)
+        if not history_id:
+            # Owner (or its historyId) not known yet — defer and retry when a
+            # result registers the source→uuid and uuid→historyId mappings.
+            self._pending_attachments.append(path)
+            return
+
+        self._upload_attachment(path, history_id)
+
+    def _resolve_history_id(self, source_name: str) -> str:
+        """Resolve an attachment's source filename to its owning result's historyId.
+
+        Two hops: source filename → owning Allure result uuid → historyId. Both
+        are learned from result/container files, which may arrive after the
+        attachment (watch-mode ordering). Returns "" when either hop is missing,
+        signalling the caller to defer rather than skip.
+        """
+        result_uuid = self._attachment_result_map.get(source_name, "")
         if not result_uuid:
-            # Attachment not referenced by any result — skip
+            return ""
+        return self._result_uuid_to_history.get(result_uuid, "")
+
+    def _retry_pending_attachments(self) -> None:
+        """Upload any buffered attachments whose owner mapping is now known.
+
+        Attachments still without a mapping remain pending; they are only
+        counted as skipped by _flush_pending_attachments() at flush time, once
+        no further mappings can arrive.
+        """
+        if not self._pending_attachments:
+            return
+        still_pending: list[Path] = []
+        for path in self._pending_attachments:
+            history_id = self._resolve_history_id(path.name)
+            if history_id:
+                self._upload_attachment(path, history_id)
+            else:
+                still_pending.append(path)
+        self._pending_attachments = still_pending
+
+    def _flush_pending_attachments(self) -> None:
+        """Resolve remaining deferred attachments; count the truly orphaned as skipped.
+
+        Called at end-of-run when no further result/container mappings can
+        arrive. Any attachment still without an owner is genuinely unreferenced
+        and is counted as skipped.
+        """
+        self._retry_pending_attachments()
+        for path in self._pending_attachments:
             self._summary.attachments_skipped += 1
-            logger.debug("Skipping attachment with no result reference: %s", path.name)
+            logger.warning(
+                "Skipping attachment with no matching result: %s", path.name
+            )
+        self._pending_attachments = []
+
+    def _upload_attachment(self, path: Path, history_id: str) -> None:
+        """POST a single attachment to the Charisma attachment API.
+
+        ``resultId`` is the backend-derived id (uuid5 of launch/historyId), the
+        same value the backend stores as ``test_results.id``. Sending the raw
+        Allure uuid here was the attachments-skipped bug: the backend validates
+        the resultId against the stored id and returns 404 on a mismatch.
+
+        Transient failures (5xx, 429, connect/timeout) are retried with the same
+        exponential backoff as result batches — attachments were previously the
+        only backend call with no retry, so a momentary blip permanently dropped
+        an attachment a single retry would have delivered. On terminal failure the
+        attachment is counted skipped and logged at WARNING (not DEBUG): a silent
+        DEBUG-only skip is exactly what hid the original bug.
+        """
+        # Fail fast rather than fabricate a wrong id: the backend derives the
+        # stored result id from launch_id, so an empty launch_id computes a
+        # well-formed but wrong id that always 404s. Never send that.
+        if not self._launch_id:
+            self._summary.attachments_skipped += 1
+            logger.warning(
+                "Cannot upload attachment %s: no open launch", path.name
+            )
             return
 
         try:
             content = path.read_bytes()
-            files = {"file": (path.name, content)}
-            data = {"name": path.name, "resultId": result_uuid}
+        except OSError as e:
+            self._summary.attachments_skipped += 1
+            logger.warning("Cannot read attachment %s: %s", path.name, e)
+            return
 
-            response = self._client.post(
-                f"/api/v1/launches/{self._launch_id}/attachments",
-                files=files,
-                data=data,
-            )
-            if response.status_code == 201:
-                self._summary.attachments_sent += 1
-            else:
+        result_id = backend_result_id(self._launch_id, history_id)
+        files = {"file": (path.name, content)}
+        data = {"name": path.name, "resultId": result_id}
+
+        for attempt in range(MAX_RETRIES + 1):
+            try:
+                response = self._client.post(
+                    f"/api/v1/launches/{self._launch_id}/attachments",
+                    files=files,
+                    data=data,
+                )
+                if response.status_code == 201:
+                    self._summary.attachments_sent += 1
+                    return
+                if response.status_code in RETRYABLE_STATUS_CODES and attempt < MAX_RETRIES:
+                    time.sleep(exponential_backoff(attempt))
+                    continue
+                # Non-retryable status (e.g. 404) or retries exhausted.
                 self._summary.attachments_skipped += 1
-                logger.debug("Attachment upload failed: HTTP %d for %s", response.status_code, path.name)
-        except (httpx.ConnectError, httpx.TimeoutException) as e:
-            self._summary.attachments_skipped += 1
-            logger.debug("Attachment upload connection error: %s for %s", e, path.name)
-        except Exception:
-            self._summary.attachments_skipped += 1
-            logger.debug("Attachment upload unexpected error for %s", path.name, exc_info=True)
+                logger.warning(
+                    "Attachment upload failed: HTTP %d for %s",
+                    response.status_code,
+                    path.name,
+                )
+                return
+            except (httpx.ConnectError, httpx.TimeoutException) as e:
+                if attempt < MAX_RETRIES:
+                    time.sleep(exponential_backoff(attempt))
+                    continue
+                self._summary.attachments_skipped += 1
+                logger.warning(
+                    "Attachment upload failed after %d retries: %s for %s",
+                    MAX_RETRIES,
+                    e,
+                    path.name,
+                )
+                return
+            except Exception:
+                # Non-network error (e.g. malformed client state) — not retryable.
+                self._summary.attachments_skipped += 1
+                logger.warning(
+                    "Attachment upload unexpected error for %s", path.name, exc_info=True
+                )
+                return
 
     def _try_associate_containers(self) -> None:
         """Try to associate buffered containers with known results."""
@@ -549,5 +710,10 @@ class Uploader:
         if self._batch:
             self._flush_batch()
 
+        # All queued events are processed and no further mappings can arrive:
+        # resolve any deferred attachments now, counting the truly orphaned as
+        # skipped. Runs before container finalization for symmetry with results.
+        self._flush_pending_attachments()
+
         self._summary.containers_sent += len(self._pending_containers)
         self._pending_containers.clear()