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

{charisma_cli-0.1.6 → charisma_cli-0.2.1}/.gitignore

@@ -132,3 +132,4 @@ ltm/snapshots/*
 backend/coverage.json
 */__pycache__/*
 allure-results/*
+allure-results-live/

{charisma_cli-0.1.6 → charisma_cli-0.2.1}/PKG-INFO

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

{charisma_cli-0.1.6 → charisma_cli-0.2.1}/pyproject.toml

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

{charisma_cli-0.1.6 → charisma_cli-0.2.1}/src/charisma_cli/__init__.py

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

{charisma_cli-0.1.6 → charisma_cli-0.2.1}/src/charisma_cli/main.py

@@ -16,6 +16,15 @@ from charisma_cli.subprocess_mgr import SubprocessManager
 from charisma_cli.uploader import Uploader
 from charisma_cli.watcher import ResultsWatcher, classify_file
 
+# Post-subprocess settle window for the watch command. allure-pytest under heavy
+# xdist can finish flushing its result files to disk seconds after the test
+# subprocess exits; settle_scan keeps polling until the directory is quiet for
+# SETTLE_QUIET_PERIOD or SETTLE_MAX_WAIT elapses. The window is deliberately
+# wider than settle_scan's own defaults (1s/15s) because a real CI burst can
+# land well past 15s — a too-short window is the watch results_sent=0 bug.
+SETTLE_QUIET_PERIOD = 2.0
+SETTLE_MAX_WAIT = 60.0
+
 
 @click.group()
 @click.version_option(version=__version__, prog_name="charismactl")
@@ -185,17 +194,19 @@ def watch(
     mgr.spawn(command)
     exit_code = mgr.wait()
 
-    # After subprocess exits (crash or normal): flush debouncing files, then
-    # keep scanning until the results directory settles. allure-pytest writes
-    # its result files in a burst during test-process teardown; under high
-    # xdist parallelism that burst can land AFTER the subprocess exits, so a
-    # single scan taken here races the OS flush and captures nothing (the
-    # watch results_sent=0 bug). settle_scan reconciles until the directory is
-    # quiet, capturing the whole burst before we drain.
+    # Reconcile the results directory after the subprocess exits. allure-pytest
+    # writes its result files in a burst during test-process teardown; under
+    # heavy xdist parallelism that burst can finish flushing to disk seconds
+    # after the subprocess returns. flush_pending drains any files still in the
+    # 500ms debounce window; settle_scan then polls the directory until it is
+    # quiet, capturing the whole late burst before we drain. Without a wide
+    # enough window the queue is drained empty and nothing is sent (the watch
+    # results_sent=0 bug). The shared seen-set keeps every file exactly-once.
     watcher.flush_pending()
-    watcher.settle_scan()
+    watcher.settle_scan(quiet_period=SETTLE_QUIET_PERIOD, max_wait=SETTLE_MAX_WAIT)
 
-    # Drain and close — stop watcher AFTER drain so all files are processed
+    # Drain and close — stop the watcher AFTER drain so the consumer's final
+    # queue flush still sees anything the observer enqueued during drain.
     uploader.drain(timeout=config.drain_timeout)
     watcher.stop()
     uploader.stop()

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

@@ -3,6 +3,7 @@
 from dataclasses import dataclass, field
 from enum import IntEnum
 from pathlib import Path
+from typing import Any
 
 
 class FileCategory(IntEnum):
@@ -52,6 +53,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.1.6 → charisma_cli-0.2.1}/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.1.6 → charisma_cli-0.2.1}/src/charisma_cli/uploader.py

@@ -12,12 +12,18 @@ import httpx
 
 from charisma_cli.config import Config
 from charisma_cli.models import (
+    AttachmentRef,
     ContainerData,
     FileCategory,
     FileEvent,
     UploadSummary,
 )
-from charisma_cli.parser import extract_attachment_refs, parse_container_file, parse_result_file
+from charisma_cli.parser import (
+    extract_attachment_refs,
+    extract_container_attachment_refs,
+    parse_container_file,
+    parse_result_file,
+)
 from charisma_cli.retry import MAX_RETRIES, RETRYABLE_STATUS_CODES, exponential_backoff
 
 logger = logging.getLogger(__name__)
@@ -26,6 +32,11 @@ _BATCH_SIZE = 50
 _BATCH_TIMEOUT_SECONDS = 2.0
 _CONTAINER_ASSOCIATION_TIMEOUT = 60.0
 
+# Sentinel expectedTests for CLI launches: the total count is unknown at open
+# time (directory-watch streaming), so we send the backend maximum. This keeps
+# the launch in 'receiving' across all appends; close_launch() finalizes it.
+_UNKNOWN_EXPECTED_TESTS = 1_000_000
+
 
 def _epoch_ms_to_iso(epoch_ms: int) -> str:
     """Convert epoch milliseconds to ISO 8601 UTC string."""
@@ -65,6 +76,13 @@ class Uploader:
         self._known_result_uuids: set[str] = set()
         # Map source filename → result_uuid for attachment uploads
         self._attachment_result_map: 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:
@@ -173,9 +191,14 @@ class Uploader:
         """
         self.ensure_client()
 
+        # The CLI streams from a watched directory and does not know the total
+        # test count at open time. Send a high sentinel so the launch stays
+        # 'receiving' through every append; finalization is driven by
+        # close_launch() at the end of the run (or the stale-launch finalizer as
+        # a backstop), never by the append counter reaching expectedTests.
         payload: dict[str, Any] = {
             "projectAlias": self._config.project,
-            "expectedTests": 1000,
+            "expectedTests": _UNKNOWN_EXPECTED_TESTS,
         }
         if self._config.build_id:
             payload["buildId"] = self._config.build_id
@@ -306,16 +329,16 @@ class Uploader:
         if result.uuid:
             self._known_result_uuids.add(result.uuid)
 
-        # Build API payload
+        # Build API payload (snake_case wire format — shared TestResultInput contract)
         payload: dict[str, Any] = {
-            "testId": result.testId,
+            "test_id": result.testId,
             "outcome": result.outcome,
             "duration_ms": result.duration_ms,
         }
         if result.name:
             payload["name"] = result.name
         if result.full_name:
-            payload["fullName"] = result.full_name
+            payload["full_name"] = result.full_name
         if result.error_message:
             payload["error_message"] = result.error_message
         if result.stack_trace:
@@ -344,10 +367,11 @@ class Uploader:
         if result.ended_at is not None:
             payload["ended_at"] = _epoch_ms_to_iso(result.ended_at)
 
-        # Serialize Allure steps and links into labels dict (per design field mapping)
+        # Serialize Allure steps into the first-class `steps` array (StepInput
+        # wire shape). Previously packed as a JSON string in labels["steps"] —
+        # dropped in favor of the shared TestResultInput contract.
         steps = raw_data.get("steps")
         if steps:
-            # Normalize Allure step format to match the schema _parse_steps expects
             normalized_steps = []
             for step in steps:
                 status_details = step.get("statusDetails") or {}
@@ -359,17 +383,16 @@ class Uploader:
                     "duration_ms": (stop - start) if (start and stop) else None,
                     "error_message": status_details.get("message"),
                 })
-            labels_d = payload.get("labels", {})
-            labels_d["steps"] = json.dumps(normalized_steps)
-            payload["labels"] = labels_d
+            payload["steps"] = normalized_steps
 
+        # Links and description are label-like metadata not modeled by StepInput;
+        # keep them in labels (values are strings, matching labels: dict[str, str]).
         links = raw_data.get("links")
         if links:
             labels_d = payload.get("labels", {})
             labels_d["links"] = json.dumps(links)
             payload["labels"] = labels_d
 
-        # Add description to labels if present
         description = raw_data.get("description") or raw_data.get("descriptionHtml")
         if description:
             labels_d = payload.get("labels", {})
@@ -386,37 +409,101 @@ 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, "")
         if not result_uuid:
-            # Attachment not referenced by any result — skip
+            # Owner not known yet — defer and retry when a mapping is registered.
+            self._pending_attachments.append(path)
+            return
+
+        self._upload_attachment(path, 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:
+            result_uuid = self._attachment_result_map.get(path.name, "")
+            if result_uuid:
+                self._upload_attachment(path, result_uuid)
+            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)
-            return
+        self._pending_attachments = []
 
+    def _upload_attachment(self, path: Path, result_uuid: str) -> None:
+        """POST a single attachment to the Charisma attachment API."""
         try:
             content = path.read_bytes()
             files = {"file": (path.name, content)}
@@ -539,5 +626,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()

{charisma_cli-0.1.6 → charisma_cli-0.2.1}/src/charisma_cli/watcher.py

@@ -1,5 +1,6 @@
 """Watchdog observer, stability debounce, and file classification for allure-results."""
 
+import logging
 import os
 import time
 from pathlib import Path
@@ -12,6 +13,8 @@ from watchdog.observers import Observer
 from charisma_cli.config import Config
 from charisma_cli.models import FileCategory, FileEvent
 
+logger = logging.getLogger(__name__)
+
 _TWO_MB = 2 * 1024 * 1024
 _STABILITY_SECONDS = 0.5
 
@@ -306,8 +309,10 @@ class ResultsWatcher:
             Total number of new files enqueued across all iterations.
         """
         total = 0
-        deadline = time.monotonic() + max_wait
-        last_new_at = time.monotonic()
+        started_at = time.monotonic()
+        deadline = started_at + max_wait
+        last_new_at = started_at
+        settled = False
 
         while time.monotonic() < deadline:
             new_count = self.final_scan()
@@ -317,7 +322,27 @@ class ResultsWatcher:
                 last_new_at = now
             elif now - last_new_at >= quiet_period:
                 # No new files for a full quiet period — directory has settled.
+                settled = True
                 break
             time.sleep(poll_interval)
 
+        elapsed = time.monotonic() - started_at
+        if settled:
+            logger.info(
+                "Results directory settled after %.1fs (%d file(s) captured during settle)",
+                elapsed,
+                total,
+            )
+        else:
+            # Exited on max_wait, not quiescence: the directory was still
+            # producing files when we gave up. Surface this so an operator can
+            # see teardown burned the full window rather than settling — a
+            # signal that max_wait may be too short for this workload.
+            logger.warning(
+                "settle_scan hit max_wait (%.0fs) before the results directory "
+                "settled; captured %d file(s). Some late results may be unsent.",
+                max_wait,
+                total,
+            )
+
         return total

{charisma_cli-0.1.6 → charisma_cli-0.2.1}/tests/test_integration.py

@@ -2,6 +2,7 @@
 
 import json
 import sys
+import threading
 from pathlib import Path
 
 import httpx
@@ -228,10 +229,10 @@ class TestReportingFixesEndToEnd:
         # The skipped result was sent (not dropped)
         assert results_route.called
         sent_results = json.loads(results_route.calls[0].request.content)["results"]
-        outcomes = {r["testId"]: r["outcome"] for r in sent_results}
+        outcomes = {r["test_id"]: r["outcome"] for r in sent_results}
         assert outcomes.get("hist_skip") == "skipped"
         # duration defaulted to 0 for the missing stop
-        skip_payload = next(r for r in sent_results if r["testId"] == "hist_skip")
+        skip_payload = next(r for r in sent_results if r["test_id"] == "hist_skip")
         assert skip_payload["duration_ms"] == 0
 
         # environment.properties sent as variables on close
@@ -242,3 +243,132 @@ class TestReportingFixesEndToEnd:
             "aws_region": "us-west-2",
             "workers_number": "8",
         }
+
+
+class TestSettleScanCapturesLateTeardownBurst:
+    """Regression for the `watch results_sent=0` bug — isolates the true fix.
+
+    The one behavioral property that separates the old teardown from the new is
+    settle_scan's max_wait window. allure-pytest under heavy xdist can flush its
+    result files to disk SEVERAL SECONDS after the subprocess exits. The old
+    teardown used settle_scan()'s default max_wait=15.0; the new watch teardown
+    widens it to 60.0. A file that first lands on disk AFTER the window closes is
+    never enqueued and never sent — that is the production failure.
+
+    This test drives ResultsWatcher directly (not the full CLI) with scaled-down
+    timings so it is fast and deterministic: a result file is written by a
+    background timer at t=0.3s after settle_scan starts. With a SHORT window
+    (mimicking the old code) settle_scan gives up before the file lands and
+    enqueues nothing. With a LONGER window (mimicking the new code) it is still
+    polling when the file lands and enqueues it. No reliance on OS event buffers
+    or thread scheduling — only on-disk appearance time vs the window.
+    """
+
+    def _write_result_after(self, results_dir: Path, delay: float) -> threading.Timer:
+        """Schedule a valid Allure result file to appear after `delay` seconds."""
+
+        def _write() -> None:
+            (results_dir / "late-result.json").write_text(json.dumps({
+                "uuid": "late-1",
+                "historyId": "hist_late",
+                "fullName": "tests.test_late.test_case",
+                "name": "test_case",
+                "status": "passed",
+                "start": 1000,
+                "stop": 2000,
+                "labels": [],
+                "parameters": [],
+                "attachments": [],
+            }))
+
+        timer = threading.Timer(delay, _write)
+        timer.daemon = True
+        timer.start()
+        return timer
+
+    def test_short_window_misses_late_file_long_window_captures_it(
+        self, tmp_path: Path, default_config
+    ) -> None:
+        """settle_scan with a window shorter than the file's appearance misses it;
+        a window longer than the appearance captures it. This is exactly the
+        old (max_wait=15) vs new (max_wait=60) separation, scaled to sub-second."""
+        from queue import PriorityQueue
+
+        from charisma_cli.models import FileEvent
+        from charisma_cli.watcher import ResultsWatcher
+
+        # --- OLD behavior: window closes BEFORE the file lands (t=0.3s) ---
+        old_dir = tmp_path / "old"
+        old_dir.mkdir()
+        old_queue: PriorityQueue[FileEvent] = PriorityQueue()
+        old_watcher = ResultsWatcher(str(old_dir), old_queue, default_config)
+        t1 = self._write_result_after(old_dir, delay=0.3)
+        # Do not start the observer — isolate the scan behavior from OS events.
+        old_captured = old_watcher.settle_scan(quiet_period=0.1, max_wait=0.2)
+        t1.join()
+        assert old_captured == 0, "short window should give up before the late file lands"
+        assert old_queue.empty()
+
+        # --- NEW behavior: window stays open PAST the file landing (t=0.3s) ---
+        new_dir = tmp_path / "new"
+        new_dir.mkdir()
+        new_queue: PriorityQueue[FileEvent] = PriorityQueue()
+        new_watcher = ResultsWatcher(str(new_dir), new_queue, default_config)
+        t2 = self._write_result_after(new_dir, delay=0.3)
+        new_captured = new_watcher.settle_scan(quiet_period=0.3, max_wait=2.0)
+        t2.join()
+        assert new_captured == 1, "long window should still be polling when the late file lands"
+        assert new_queue.qsize() == 1
+
+
+class TestWatchStreamsPreexistingResult:
+    """Sanity E2E: watch streams a result already on disk through the launch API.
+
+    This does NOT isolate the old/new fix (any on-disk file is caught by both).
+    It guards the happy path: watch opens a launch, sends the result, closes,
+    and reports results_sent in the summary.
+    """
+
+    @respx.mock
+    def test_watch_sends_result_and_reports_summary(self, tmp_path: Path, monkeypatch) -> None:
+        results_dir = tmp_path / "allure-results"
+        results_dir.mkdir()
+        (results_dir / "pre-result.json").write_text(json.dumps({
+            "uuid": "pre-1",
+            "historyId": "hist_pre",
+            "fullName": "tests.test_pre.test_case",
+            "name": "test_case",
+            "status": "passed",
+            "start": 1000,
+            "stop": 2000,
+            "labels": [],
+            "parameters": [],
+            "attachments": [],
+        }))
+
+        respx.post("https://charisma.test/api/v1/launches").mock(
+            return_value=httpx.Response(201, json={"launchId": "launch-pre", "projectId": "proj-uuid"})
+        )
+        results_route = respx.post(
+            "https://charisma.test/api/v1/launches/launch-pre/results"
+        ).mock(return_value=httpx.Response(200, json={"accepted": 1}))
+        respx.post("https://charisma.test/api/v1/launches/launch-pre/close").mock(
+            return_value=httpx.Response(200, json={})
+        )
+
+        monkeypatch.setenv("CHARISMA_ENDPOINT", "https://charisma.test")
+        monkeypatch.setenv("CHARISMA_TOKEN", "pre-token")
+
+        runner = CliRunner()
+        result = runner.invoke(cli, [
+            "watch",
+            "--project", "pre-project",
+            "--results", str(results_dir),
+            "--", sys.executable, "-c", "import sys; sys.exit(0)",
+        ])
+
+        assert result.exit_code == 0
+        assert results_route.called
+        sent_results = json.loads(results_route.calls[0].request.content)["results"]
+        assert any(r["test_id"] == "hist_pre" for r in sent_results)
+        assert "results_sent=1" in result.output

{charisma_cli-0.1.6 → charisma_cli-0.2.1}/tests/test_parser.py

@@ -13,6 +13,7 @@ from pathlib import Path
 from charisma_cli.models import AttachmentRef, CharismaResult, ContainerData
 from charisma_cli.parser import (
     extract_attachment_refs,
+    extract_container_attachment_refs,
     map_allure_status,
     parse_container_file,
     parse_result_file,
@@ -542,6 +543,218 @@ class TestExtractAttachmentRefs:
         assert len(refs) == 1
         assert refs[0].name == "abc-screenshot.png"
 
+    def test_attachment_nested_in_step(self) -> None:
+        """Attachment inside a step is extracted (the common Allure layout)."""
+        data = {
+            "uuid": "r7",
+            "attachments": [],
+            "steps": [
+                {
+                    "name": "click login",
+                    "status": "passed",
+                    "attachments": [
+                        {"source": "step-shot.png", "name": "shot", "type": "image/png"}
+                    ],
+                }
+            ],
+        }
+        refs = extract_attachment_refs(data, result_uuid="r7")
+
+        assert len(refs) == 1
+        assert refs[0].source == "step-shot.png"
+        assert refs[0].result_uuid == "r7"
+
+    def test_attachment_nested_in_substep(self) -> None:
+        """Attachment in a sub-step (steps within steps) is extracted recursively."""
+        data = {
+            "uuid": "r8",
+            "steps": [
+                {
+                    "name": "outer",
+                    "steps": [
+                        {
+                            "name": "inner",
+                            "attachments": [
+                                {"source": "deep.log", "name": "log", "type": "text/plain"}
+                            ],
+                        }
+                    ],
+                }
+            ],
+        }
+        refs = extract_attachment_refs(data, result_uuid="r8")
+
+        assert len(refs) == 1
+        assert refs[0].source == "deep.log"
+        assert refs[0].result_uuid == "r8"
+
+    def test_top_level_and_step_attachments_combined(self) -> None:
+        """Top-level and step-nested attachments are both collected."""
+        data = {
+            "uuid": "r9",
+            "attachments": [
+                {"source": "top.png", "name": "top", "type": "image/png"}
+            ],
+            "steps": [
+                {
+                    "name": "s1",
+                    "attachments": [
+                        {"source": "s1.png", "name": "s1", "type": "image/png"}
+                    ],
+                    "steps": [
+                        {
+                            "name": "s1a",
+                            "attachments": [
+                                {"source": "s1a.png", "name": "s1a", "type": "image/png"}
+                            ],
+                        }
+                    ],
+                },
+                {
+                    "name": "s2",
+                    "attachments": [
+                        {"source": "s2.log", "name": "s2", "type": "text/plain"}
+                    ],
+                },
+            ],
+        }
+        refs = extract_attachment_refs(data, result_uuid="r9")
+
+        sources = {ref.source for ref in refs}
+        assert sources == {"top.png", "s1.png", "s1a.png", "s2.log"}
+        assert all(ref.result_uuid == "r9" for ref in refs)
+
+    def test_steps_none_is_safe(self) -> None:
+        """A result with steps=None does not raise and returns top-level only."""
+        data = {
+            "uuid": "r10",
+            "attachments": [
+                {"source": "only-top.png", "name": "top", "type": "image/png"}
+            ],
+            "steps": None,
+        }
+        refs = extract_attachment_refs(data, result_uuid="r10")
+
+        assert len(refs) == 1
+        assert refs[0].source == "only-top.png"
+
+
+class TestExtractContainerAttachmentRefs:
+    """extract_container_attachment_refs pulls fixture attachments from a container.
+
+    Allure stores setup/teardown attachments (logs, screenshots taken in
+    fixtures) inside the container's ``befores``/``afters`` fixture steps, which
+    themselves nest ``steps`` and ``attachments``. These belong to the
+    container's child results and were never uploaded before.
+    """
+
+    def test_no_fixture_attachments_returns_empty(self) -> None:
+        container = ContainerData(
+            uuid="c1",
+            name="fix",
+            children=["res-1"],
+            befores=[{"name": "setup", "status": "passed"}],
+            afters=[],
+        )
+        refs = extract_container_attachment_refs(container)
+        assert refs == []
+
+    def test_before_attachment_bound_to_child(self) -> None:
+        """An attachment in a before-fixture is bound to the container's child result."""
+        container = ContainerData(
+            uuid="c2",
+            name="fix",
+            children=["res-1"],
+            befores=[
+                {
+                    "name": "setup_db",
+                    "attachments": [
+                        {"source": "setup.log", "name": "setup log", "type": "text/plain"}
+                    ],
+                }
+            ],
+            afters=[],
+        )
+        refs = extract_container_attachment_refs(container)
+
+        assert len(refs) == 1
+        assert refs[0].source == "setup.log"
+        assert refs[0].result_uuid == "res-1"
+
+    def test_after_attachment_nested_in_substep(self) -> None:
+        """An attachment nested in an after-fixture sub-step is extracted recursively."""
+        container = ContainerData(
+            uuid="c3",
+            name="fix",
+            children=["res-9"],
+            befores=[],
+            afters=[
+                {
+                    "name": "teardown",
+                    "steps": [
+                        {
+                            "name": "capture screenshot",
+                            "attachments": [
+                                {"source": "final.png", "name": "final", "type": "image/png"}
+                            ],
+                        }
+                    ],
+                }
+            ],
+        )
+        refs = extract_container_attachment_refs(container)
+
+        assert len(refs) == 1
+        assert refs[0].source == "final.png"
+        assert refs[0].result_uuid == "res-9"
+
+    def test_no_children_yields_no_refs(self) -> None:
+        """A container with fixture attachments but no children cannot bind them."""
+        container = ContainerData(
+            uuid="c4",
+            name="orphan",
+            children=[],
+            befores=[
+                {
+                    "name": "setup",
+                    "attachments": [
+                        {"source": "orphan.log", "name": "log", "type": "text/plain"}
+                    ],
+                }
+            ],
+            afters=[],
+        )
+        refs = extract_container_attachment_refs(container)
+        assert refs == []
+
+    def test_multi_child_fixture_attachment_bound_to_every_child(self) -> None:
+        """Suite/session-scoped fixture: attachment binds to ALL children, not just first.
+
+        Allure emits a single container with many children for class/suite/session
+        fixtures. A fixture attachment applies to every test the fixture served, so
+        binding it only to children[0] would leave the other tests without it.
+        """
+        container = ContainerData(
+            uuid="c5",
+            name="session fixture",
+            children=["res-a", "res-b", "res-c"],
+            befores=[
+                {
+                    "name": "session_setup",
+                    "attachments": [
+                        {"source": "session.log", "name": "session log", "type": "text/plain"}
+                    ],
+                }
+            ],
+            afters=[],
+        )
+        refs = extract_container_attachment_refs(container)
+
+        assert len(refs) == 3
+        owners = {ref.result_uuid for ref in refs}
+        assert owners == {"res-a", "res-b", "res-c"}
+        assert all(ref.source == "session.log" for ref in refs)
+
 
 class TestSkippedResultParsing:
     """Regression: skipped tests (no 'stop', sometimes no 'start') must parse.

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

@@ -267,6 +267,195 @@ class TestUploaderExceptionIsolation:
         assert True
 
 
+class TestUploaderAttachments:
+    """Attachments nested in steps and fixtures are registered and uploaded.
+
+    Regression for the `charismactl upload attachments_sent=0` bug: attachments
+    live inside result steps and container fixture steps, not at the result top
+    level. The uploader must register every source→result mapping so
+    _handle_attachment can upload them instead of skipping.
+    """
+
+    def _write_json(self, path: Path, data: dict) -> None:
+        import json
+        path.write_text(json.dumps(data), encoding="utf-8")
+
+    def _drive(self, uploader: Uploader, queue: PriorityQueue) -> None:
+        uploader.start()
+        uploader.drain(timeout=5.0)
+        uploader.stop()
+
+    @respx.mock
+    def test_step_nested_attachment_is_uploaded(self, tmp_path: Path) -> None:
+        """An attachment inside a result step is uploaded, not skipped."""
+        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(201, json={"id": "att-1"}))
+
+        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": [],
+            "steps": [
+                {"name": "click", "attachments": [
+                    {"source": "shot.png", "name": "shot", "type": "image/png"}
+                ]}
+            ],
+        })
+        attach_file = tmp_path / "shot.png"
+        attach_file.write_bytes(b"\x89PNG fake")
+
+        uploader = Uploader(config, queue)
+        uploader._launch_id = "launch-1"
+        queue.put(FileEvent(path=result_file, category=FileCategory.RESULT))
+        queue.put(FileEvent(path=attach_file, category=FileCategory.ATTACHMENT))
+
+        self._drive(uploader, queue)
+
+        assert uploader.summary.attachments_sent == 1
+        assert uploader.summary.attachments_skipped == 0
+        assert attach_route.called
+
+    @respx.mock
+    def test_attachment_before_result_is_deferred_then_uploaded(self, tmp_path: Path) -> None:
+        """An attachment processed BEFORE its owning result is not lost.
+
+        Watch-mode ordering race: the PriorityQueue only orders items co-present
+        at dequeue time, so an attachment can be handled before the result that
+        registers its source→uuid mapping. The attachment must be deferred and
+        uploaded once the result arrives — not counted as skipped on first sight.
+        """
+        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(201, json={"id": "att-3"}))
+
+        result_file = tmp_path / "late-result.json"
+        self._write_json(result_file, {
+            "uuid": "lr1",
+            "historyId": "hist-lr1",
+            "fullName": "tests.test_race",
+            "status": "passed",
+            "start": 1000,
+            "stop": 2000,
+            "steps": [
+                {"name": "act", "attachments": [
+                    {"source": "race.png", "name": "race", "type": "image/png"}
+                ]}
+            ],
+        })
+        attach_file = tmp_path / "race.png"
+        attach_file.write_bytes(b"\x89PNG fake")
+
+        uploader = Uploader(config, queue)
+        uploader._launch_id = "launch-1"
+
+        # Drive handlers in the adversarial order: attachment FIRST (no mapping
+        # yet → deferred), then the result (registers mapping → retry uploads it).
+        uploader.ensure_client()
+        uploader._handle_attachment(attach_file)
+        assert uploader.summary.attachments_sent == 0
+        assert uploader.summary.attachments_skipped == 0  # deferred, not skipped
+
+        uploader._handle_result(result_file)
+
+        assert uploader.summary.attachments_sent == 1
+        assert uploader.summary.attachments_skipped == 0
+        assert attach_route.called
+
+        uploader._client.close()
+
+    @respx.mock
+    def test_orphan_attachment_counted_skipped_at_flush(self, tmp_path: Path) -> None:
+        """An attachment with no owning result is counted skipped once at flush."""
+        config = _make_config()
+        queue: PriorityQueue = PriorityQueue()
+
+        uploader = Uploader(config, queue)
+        uploader._launch_id = "launch-1"
+        uploader.ensure_client()
+
+        orphan = tmp_path / "orphan.png"
+        orphan.write_bytes(b"\x89PNG")
+
+        uploader._handle_attachment(orphan)
+        assert uploader.summary.attachments_skipped == 0  # deferred first
+
+        # No result/container ever registers it → flush counts it skipped once.
+        uploader._flush_pending_attachments()
+        assert uploader.summary.attachments_skipped == 1
+        # Idempotent: a second flush must not double-count.
+        uploader._flush_pending_attachments()
+        assert uploader.summary.attachments_skipped == 1
+
+        uploader._client.close()
+
+    @respx.mock
+    def test_fixture_attachment_is_uploaded(self, tmp_path: Path) -> None:
+        """An attachment inside a container's before-fixture is uploaded."""
+        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(201, json={"id": "att-2"}))
+
+        result_file = tmp_path / "res1-result.json"
+        self._write_json(result_file, {
+            "uuid": "res1",
+            "historyId": "hist-res1",
+            "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": ["res1"],
+            "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-1"
+        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))
+
+        self._drive(uploader, queue)
+
+        assert uploader.summary.attachments_sent == 1
+        assert uploader.summary.attachments_skipped == 0
+        assert attach_route.called
+
+
 class TestUploaderSummary:
     """Uploader.summary returns accurate UploadSummary."""
 

{charisma_cli-0.1.6 → charisma_cli-0.2.1}/tests/test_watcher.py

@@ -733,8 +733,14 @@ class TestSettleScan:
             seen.add(key)
         assert len(seen) == 10
 
-    def test_settles_quickly_when_directory_empty(self, tmp_path: Path) -> None:
-        """An empty directory settles after one quiet period and enqueues nothing."""
+    def test_settles_quickly_when_directory_empty(self, tmp_path: Path, caplog) -> None:
+        """An empty directory settles after one quiet period and enqueues nothing.
+
+        Also asserts the settle path logs at INFO (not WARNING) — settling
+        cleanly is the normal case and must not raise a max_wait warning.
+        """
+        import logging
+
         results_dir = tmp_path / "allure-results"
         results_dir.mkdir()
 
@@ -742,19 +748,26 @@ class TestSettleScan:
         watcher = ResultsWatcher(str(results_dir), queue, _make_config())
 
         start = time.monotonic()
-        enqueued = watcher.settle_scan(quiet_period=0.3, max_wait=5.0, poll_interval=0.1)
+        with caplog.at_level(logging.INFO, logger="charisma_cli.watcher"):
+            enqueued = watcher.settle_scan(quiet_period=0.3, max_wait=5.0, poll_interval=0.1)
         elapsed = time.monotonic() - start
 
         assert enqueued == 0
         assert queue.empty()
         assert elapsed < 4.0  # returned on the quiet-period, not the max_wait cap
+        # Clean settle → INFO log, never a max_wait WARNING.
+        assert any(r.levelno == logging.INFO for r in caplog.records)
+        assert not any(r.levelno == logging.WARNING for r in caplog.records)
 
-    def test_respects_max_wait_when_directory_never_settles(self, tmp_path: Path) -> None:
+    def test_respects_max_wait_when_directory_never_settles(self, tmp_path: Path, caplog) -> None:
         """max_wait caps total time even if files keep arriving continuously.
 
         This documents the one bounded caveat: a directory that never goes quiet
-        stops at max_wait rather than blocking teardown forever.
+        stops at max_wait rather than blocking teardown forever. Also asserts a
+        WARNING is emitted so the up-to-max_wait teardown is observable rather
+        than silent.
         """
+        import logging
         import threading
 
         results_dir = tmp_path / "allure-results"
@@ -776,7 +789,8 @@ class TestSettleScan:
         writer.start()
         try:
             start = time.monotonic()
-            watcher.settle_scan(quiet_period=0.5, max_wait=1.5, poll_interval=0.1)
+            with caplog.at_level(logging.WARNING, logger="charisma_cli.watcher"):
+                watcher.settle_scan(quiet_period=0.5, max_wait=1.5, poll_interval=0.1)
             elapsed = time.monotonic() - start
         finally:
             stop.set()
@@ -784,6 +798,11 @@ class TestSettleScan:
 
         # Should stop at ~max_wait, not run indefinitely.
         assert 1.5 <= elapsed < 4.0
+        # Hitting max_wait must surface a WARNING (observability, not silent).
+        assert any(
+            r.levelno == logging.WARNING and "max_wait" in r.getMessage()
+            for r in caplog.records
+        )
 
     def test_scales_to_large_burst(self, tmp_path: Path) -> None:
         """A large number of files (simulating many workers/tests) is fully captured.