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

{charisma_cli-0.2.1 → 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.1 → charisma_cli-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: charisma-cli
-Version: 0.2.1
+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.1 → charisma_cli-0.2.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "charisma-cli"
-version = "0.2.1"
+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.1 → 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.2.1"
+__version__ = "0.2.2"

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

@@ -4,6 +4,32 @@ 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):

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

@@ -17,6 +17,7 @@ from charisma_cli.models import (
     FileCategory,
     FileEvent,
     UploadSummary,
+    backend_result_id,
 )
 from charisma_cli.parser import (
     extract_attachment_refs,
@@ -74,8 +75,15 @@ 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
@@ -328,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] = {
@@ -463,13 +478,27 @@ class Uploader:
             self._summary.attachments_skipped += 1
             return
 
-        result_uuid = self._attachment_result_map.get(path.name, "")
-        if not result_uuid:
-            # Owner not known yet — defer and retry when a mapping is registered.
+        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, result_uuid)
+        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:
+            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.
@@ -482,9 +511,9 @@ class Uploader:
             return
         still_pending: list[Path] = []
         for path in self._pending_attachments:
-            result_uuid = self._attachment_result_map.get(path.name, "")
-            if result_uuid:
-                self._upload_attachment(path, result_uuid)
+            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
@@ -499,32 +528,87 @@ class Uploader:
         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, result_uuid: str) -> None:
-        """POST a single attachment to the Charisma attachment API."""
+    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."""

{charisma_cli-0.2.1 → charisma_cli-0.2.2}/tests/test_uploader.py

@@ -520,3 +520,307 @@ class TestUploaderDrainFlushesBatch:
         assert results_route.called
 
         uploader.stop()
+
+
+class TestAttachmentResultIdContract:
+    """The attachment `resultId` must match the backend's stored test_results.id.
+
+    Regression for the `attachments_sent=0, attachments_skipped=N` production bug.
+    The backend derives test_results.id as uuid5(NAMESPACE_URL, f"{launch_id}/{test_id}")
+    where test_id is the Allure historyId (see backend models/testresults.py). The CLI
+    previously sent the raw Allure `uuid` as resultId, which never matches that stored
+    id, so the backend returned 404 RESULT_NOT_FOUND and every attachment was skipped.
+
+    These tests pin the on-the-wire resultId to the backend contract so the mismatch
+    cannot silently return.
+    """
+
+    def _write_json(self, path: Path, data: dict) -> None:
+        import json
+        path.write_text(json.dumps(data), encoding="utf-8")
+
+    @staticmethod
+    def _expected_result_id(launch_id: str, history_id: str) -> str:
+        from uuid import NAMESPACE_URL, uuid5
+        return str(uuid5(NAMESPACE_URL, f"{launch_id}/{history_id}"))
+
+    @staticmethod
+    def _sent_result_id(route) -> str:
+        """Extract the resultId form field from the recorded multipart request."""
+        request = route.calls[0].request
+        body = request.content.decode("utf-8", errors="replace")
+        # multipart body contains: name="resultId"\r\n\r\n<value>\r\n
+        marker = 'name="resultId"'
+        idx = body.find(marker)
+        assert idx != -1, f"resultId field not found in request body:\n{body}"
+        after = body[idx + len(marker):]
+        # skip the two CRLFs separating headers from the value
+        value = after.split("\r\n\r\n", 1)[1]
+        return value.split("\r\n", 1)[0]
+
+    @respx.mock
+    def test_top_level_attachment_result_id_matches_backend(self, tmp_path: Path) -> None:
+        """A top-level attachment sends resultId = uuid5(launch/historyId), not the Allure uuid.
+
+        Mirrors the real repro: the result's file uuid differs from its historyId,
+        and attachments are declared at the result top level.
+        """
+        config = _make_config()
+        queue: PriorityQueue = PriorityQueue()
+        launch_id = "launch-1"
+        history_id = "601485468354fb8daff78d8e009a0714"
+        allure_uuid = "f7451cdd-7ad3-48fa-bb88-61b65e408645"
+
+        respx.post(f"https://charisma.test/api/v1/launches/{launch_id}/results").mock(
+            return_value=httpx.Response(200, json={"accepted": 1})
+        )
+        attach_route = respx.post(
+            f"https://charisma.test/api/v1/launches/{launch_id}/attachments"
+        ).mock(return_value=httpx.Response(201, json={"id": "att-1"}))
+
+        result_file = tmp_path / "09d4-result.json"
+        self._write_json(result_file, {
+            "uuid": allure_uuid,
+            "historyId": history_id,
+            "fullName": "tests.emea.dsp.test_x",
+            "status": "broken",
+            "start": 1000,
+            "stop": 2000,
+            "attachments": [
+                {"source": "shot.png", "name": "screenshot", "type": "image/png"}
+            ],
+        })
+        attach_file = tmp_path / "shot.png"
+        attach_file.write_bytes(b"\x89PNG fake")
+
+        uploader = Uploader(config, queue)
+        uploader._launch_id = launch_id
+        queue.put(FileEvent(path=result_file, category=FileCategory.RESULT))
+        queue.put(FileEvent(path=attach_file, category=FileCategory.ATTACHMENT))
+
+        uploader.start()
+        uploader.drain(timeout=5.0)
+        uploader.stop()
+
+        assert uploader.summary.attachments_sent == 1
+        assert uploader.summary.attachments_skipped == 0
+        assert attach_route.called
+
+        sent = self._sent_result_id(attach_route)
+        expected = self._expected_result_id(launch_id, history_id)
+        assert sent == expected, (
+            f"resultId sent={sent} but backend stores id={expected} "
+            f"(uuid5 of launch/historyId). Sending the Allure uuid ({allure_uuid}) "
+            "is the attachments-skipped bug."
+        )
+        assert sent != allure_uuid
+
+    @respx.mock
+    def test_fixture_attachment_result_id_matches_backend(self, tmp_path: Path) -> None:
+        """A container/fixture attachment resolves to its child's historyId-based id."""
+        config = _make_config()
+        queue: PriorityQueue = PriorityQueue()
+        launch_id = "launch-1"
+        child_history = "hist-child-777"
+        child_uuid = "res1-uuid"
+
+        respx.post(f"https://charisma.test/api/v1/launches/{launch_id}/results").mock(
+            return_value=httpx.Response(200, json={"accepted": 1})
+        )
+        attach_route = respx.post(
+            f"https://charisma.test/api/v1/launches/{launch_id}/attachments"
+        ).mock(return_value=httpx.Response(201, json={"id": "att-2"}))
+
+        result_file = tmp_path / "res1-result.json"
+        self._write_json(result_file, {
+            "uuid": child_uuid,
+            "historyId": child_history,
+            "fullName": "tests.test_fix",
+            "status": "passed",
+            "start": 1000,
+            "stop": 2000,
+        })
+        container_file = tmp_path / "c1-container.json"
+        self._write_json(container_file, {
+            "uuid": "c1",
+            "name": "fixture",
+            "children": [child_uuid],
+            "befores": [
+                {"name": "setup", "attachments": [
+                    {"source": "setup.log", "name": "setup log", "type": "text/plain"}
+                ]}
+            ],
+            "afters": [],
+        })
+        attach_file = tmp_path / "setup.log"
+        attach_file.write_text("fixture output")
+
+        uploader = Uploader(config, queue)
+        uploader._launch_id = launch_id
+        queue.put(FileEvent(path=result_file, category=FileCategory.RESULT))
+        queue.put(FileEvent(path=container_file, category=FileCategory.CONTAINER))
+        queue.put(FileEvent(path=attach_file, category=FileCategory.ATTACHMENT))
+
+        uploader.start()
+        uploader.drain(timeout=5.0)
+        uploader.stop()
+
+        assert uploader.summary.attachments_sent == 1
+        assert uploader.summary.attachments_skipped == 0
+
+        sent = self._sent_result_id(attach_route)
+        expected = self._expected_result_id(launch_id, child_history)
+        assert sent == expected, (
+            f"fixture attachment resultId sent={sent} but backend stores {expected}"
+        )
+
+
+class TestAttachmentUploadResilience:
+    """Attachment uploads must be retried on transient failures and fail visibly.
+
+    Review findings: attachment uploads were the only backend call with no retry
+    (unlike _send_batch and launch open/close), and every failure/skip was logged
+    at DEBUG — below the CLI's effective WARNING floor — so failures were invisible,
+    recreating the very 'attachments silently skipped' bug this work targets.
+    """
+
+    def _write_json(self, path: Path, data: dict) -> None:
+        import json
+        path.write_text(json.dumps(data), encoding="utf-8")
+
+    def _result_with_attachment(self, tmp_path: Path) -> tuple[Path, Path]:
+        result_file = tmp_path / "r1-result.json"
+        self._write_json(result_file, {
+            "uuid": "r1",
+            "historyId": "hist-r1",
+            "fullName": "tests.test_it",
+            "status": "passed",
+            "start": 1000,
+            "stop": 2000,
+            "attachments": [
+                {"source": "shot.png", "name": "shot", "type": "image/png"}
+            ],
+        })
+        attach_file = tmp_path / "shot.png"
+        attach_file.write_bytes(b"\x89PNG fake")
+        return result_file, attach_file
+
+    @respx.mock
+    def test_attachment_retries_transient_5xx_then_succeeds(self, tmp_path: Path, monkeypatch) -> None:
+        """A 503 followed by a 201 must retry and ultimately count as sent."""
+        # Neutralize backoff sleeps so the test is fast.
+        monkeypatch.setattr("charisma_cli.uploader.exponential_backoff", lambda attempt: 0.0)
+
+        config = _make_config()
+        queue: PriorityQueue = PriorityQueue()
+
+        respx.post("https://charisma.test/api/v1/launches/launch-1/results").mock(
+            return_value=httpx.Response(200, json={"accepted": 1})
+        )
+        attach_route = respx.post(
+            "https://charisma.test/api/v1/launches/launch-1/attachments"
+        ).mock(side_effect=[
+            httpx.Response(503),
+            httpx.Response(201, json={"id": "att-1"}),
+        ])
+
+        result_file, attach_file = self._result_with_attachment(tmp_path)
+
+        uploader = Uploader(config, queue)
+        uploader._launch_id = "launch-1"
+        uploader.ensure_client()
+        uploader._handle_result(result_file)
+        uploader._handle_attachment(attach_file)
+
+        assert uploader.summary.attachments_sent == 1
+        assert uploader.summary.attachments_skipped == 0
+        assert attach_route.call_count == 2  # retried once
+
+        uploader._client.close()
+
+    @respx.mock
+    def test_attachment_gives_up_after_max_retries_and_warns(self, tmp_path: Path, monkeypatch, caplog) -> None:
+        """Persistent 5xx exhausts retries, counts skipped once, and logs at WARNING."""
+        import logging
+        monkeypatch.setattr("charisma_cli.uploader.exponential_backoff", lambda attempt: 0.0)
+
+        config = _make_config()
+        queue: PriorityQueue = PriorityQueue()
+
+        respx.post("https://charisma.test/api/v1/launches/launch-1/results").mock(
+            return_value=httpx.Response(200, json={"accepted": 1})
+        )
+        attach_route = respx.post(
+            "https://charisma.test/api/v1/launches/launch-1/attachments"
+        ).mock(return_value=httpx.Response(503))
+
+        result_file, attach_file = self._result_with_attachment(tmp_path)
+
+        uploader = Uploader(config, queue)
+        uploader._launch_id = "launch-1"
+        uploader.ensure_client()
+        uploader._handle_result(result_file)
+
+        with caplog.at_level(logging.WARNING, logger="charisma_cli.uploader"):
+            uploader._handle_attachment(attach_file)
+
+        assert uploader.summary.attachments_sent == 0
+        assert uploader.summary.attachments_skipped == 1  # counted exactly once
+        # MAX_RETRIES(3) + initial = 4 attempts
+        assert attach_route.call_count == 4
+        assert any(r.levelno >= logging.WARNING for r in caplog.records), (
+            "a persistent attachment upload failure must be visible at WARNING+, not DEBUG"
+        )
+
+        uploader._client.close()
+
+    @respx.mock
+    def test_attachment_non_retryable_404_warns_and_does_not_retry(self, tmp_path: Path, caplog) -> None:
+        """A 404 (non-retryable) is skipped once, logged at WARNING, not retried."""
+        import logging
+        config = _make_config()
+        queue: PriorityQueue = PriorityQueue()
+
+        respx.post("https://charisma.test/api/v1/launches/launch-1/results").mock(
+            return_value=httpx.Response(200, json={"accepted": 1})
+        )
+        attach_route = respx.post(
+            "https://charisma.test/api/v1/launches/launch-1/attachments"
+        ).mock(return_value=httpx.Response(404, json={"error": "RESULT_NOT_FOUND"}))
+
+        result_file, attach_file = self._result_with_attachment(tmp_path)
+
+        uploader = Uploader(config, queue)
+        uploader._launch_id = "launch-1"
+        uploader.ensure_client()
+        uploader._handle_result(result_file)
+
+        with caplog.at_level(logging.WARNING, logger="charisma_cli.uploader"):
+            uploader._handle_attachment(attach_file)
+
+        assert uploader.summary.attachments_skipped == 1
+        assert attach_route.call_count == 1  # NOT retried
+        assert any(r.levelno >= logging.WARNING for r in caplog.records)
+
+        uploader._client.close()
+
+    def test_upload_attachment_without_launch_id_fails_fast(self, tmp_path: Path) -> None:
+        """_upload_attachment must not fabricate an id from a missing launch_id.
+
+        The backend derives test_results.id from launch_id/historyId; computing it
+        from an empty launch_id yields a well-formed-but-wrong id that 404s. Guard
+        instead of masking None with 'or ""'.
+        """
+        config = _make_config()
+        queue: PriorityQueue = PriorityQueue()
+
+        attach_file = tmp_path / "shot.png"
+        attach_file.write_bytes(b"\x89PNG fake")
+
+        uploader = Uploader(config, queue)
+        uploader._launch_id = None  # no launch
+
+        # Directly invoking the upload with no launch must count skipped, not POST.
+        uploader._upload_attachment(attach_file, "hist-r1")
+        assert uploader.summary.attachments_sent == 0
+        assert uploader.summary.attachments_skipped == 1