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

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

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

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

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

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

@@ -11,6 +11,7 @@ from charisma_cli import __version__
 from charisma_cli.config import Config
 from charisma_cli.launch_url import build_launch_url, emit_github_output
 from charisma_cli.models import FileEvent
+from charisma_cli.parser import parse_environment_properties
 from charisma_cli.subprocess_mgr import SubprocessManager
 from charisma_cli.uploader import Uploader
 from charisma_cli.watcher import ResultsWatcher, classify_file
@@ -60,6 +61,18 @@ def _open_launch_or_exit(uploader: Uploader, config: Config) -> str:
     return launch_id
 
 
+def _read_launch_variables(config: Config) -> dict[str, str]:
+    """Read Allure environment.properties from the results dir, if present.
+
+    Returns the parsed key/value variables (empty dict if the file is absent),
+    to be attached to the launch at close time.
+    """
+    props_path = Path(config.results_dir) / "environment.properties"
+    if not props_path.is_file():
+        return {}
+    return parse_environment_properties(props_path)
+
+
 def _surface_launch_url(uploader: Uploader) -> None:
     """Print the Charisma launch URL and expose it to GitHub Actions.
 
@@ -172,11 +185,15 @@ def watch(
     mgr.spawn(command)
     exit_code = mgr.wait()
 
-    # After subprocess exits (crash or normal): flush debouncing files and scan
-    # for anything the watcher missed entirely. This prevents data loss when
-    # parallel test workers write results in bursts just before crash.
+    # 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.
     watcher.flush_pending()
-    watcher.final_scan()
+    watcher.settle_scan()
 
     # Drain and close — stop watcher AFTER drain so all files are processed
     uploader.drain(timeout=config.drain_timeout)
@@ -184,7 +201,7 @@ def watch(
     uploader.stop()
 
     uploader.ensure_client()
-    uploader.close_launch()
+    uploader.close_launch(variables=_read_launch_variables(config))
     if uploader._client is not None:
         uploader._client.close()
         uploader._client = None
@@ -247,7 +264,7 @@ def upload(
 
     # Close launch
     uploader.ensure_client()
-    uploader.close_launch()
+    uploader.close_launch(variables=_read_launch_variables(config))
     uploader.stop()
 
     _print_summary(uploader)

{charisma_cli-0.1.4 → charisma_cli-0.1.6}/src/charisma_cli/parser.py

@@ -54,15 +54,18 @@ def parse_result_file(path: Path) -> CharismaResult | None:
         logger.warning("Result file is not a JSON object: %s", path)
         return None
 
-    # Required fields
+    # uuid is the only strictly required field. start/stop are optional:
+    # skipped tests (and some setup/teardown-only results) never execute, so
+    # Allure omits `stop` (and sometimes `start`). Requiring them here silently
+    # dropped skipped results before they were ever sent to Charisma.
     uuid = data.get("uuid")
+    if uuid is None:
+        logger.warning("Result file missing required field (uuid): %s", path)
+        return None
+
     start = data.get("start")
     stop = data.get("stop")
 
-    if uuid is None or start is None or stop is None:
-        logger.warning("Result file missing required fields (uuid/start/stop): %s", path)
-        return None
-
     # testId: prefer historyId, fallback to fullName
     history_id = data.get("historyId")
     full_name = data.get("fullName")
@@ -72,8 +75,9 @@ def parse_result_file(path: Path) -> CharismaResult | None:
         logger.warning("Result file missing both historyId and fullName: %s", path)
         return None
 
-    # Compute duration
-    duration_ms = stop - start
+    # Compute duration only when both timestamps are present; otherwise 0
+    # (e.g. skipped tests that never ran).
+    duration_ms = (stop - start) if (start is not None and stop is not None) else 0
 
     # Status mapping
     status = data.get("status", "")
@@ -145,6 +149,42 @@ def parse_container_file(path: Path) -> ContainerData | None:
     )
 
 
+def parse_environment_properties(path: Path) -> dict[str, str]:
+    """Parse an Allure ``environment.properties`` file into a key/value dict.
+
+    The file is a standard Java-style properties file: ``key=value`` per line,
+    with ``#`` / ``!`` comment lines and blank lines ignored. Values may contain
+    ``=`` (only the first ``=`` splits key from value). These become the
+    launch-level "Variables" shown in Charisma.
+
+    Args:
+        path: Path to the environment.properties file.
+
+    Returns:
+        Dict of variable name → value (both stripped). Empty dict if the file
+        is missing, unreadable, or contains no valid entries.
+    """
+    try:
+        text = path.read_text(encoding="utf-8")
+    except (OSError, FileNotFoundError):
+        logger.warning("Cannot read environment.properties: %s", path)
+        return {}
+
+    variables: dict[str, str] = {}
+    for line in text.splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#") or stripped.startswith("!"):
+            continue
+        if "=" not in stripped:
+            continue
+        key, _, value = stripped.partition("=")
+        key = key.strip()
+        if key:
+            variables[key] = value.strip()
+
+    return variables
+
+
 def extract_attachment_refs(result_data: dict, result_uuid: str) -> list[AttachmentRef]:
     """Extract attachment references from an Allure result data dict.
 

{charisma_cli-0.1.4 → charisma_cli-0.1.6}/src/charisma_cli/uploader.py

@@ -206,15 +206,24 @@ class Uploader:
 
         return None
 
-    def close_launch(self) -> None:
-        """Close the streaming launch via the API."""
+    def close_launch(self, variables: dict[str, str] | None = None) -> None:
+        """Close the streaming launch via the API.
+
+        Args:
+            variables: Optional launch-level key/value metadata (parsed from
+                Allure environment.properties) to persist on the launch.
+        """
         self.ensure_client()
         if self._launch_id is None:
             return
 
+        body = {"variables": variables} if variables else None
+
         for attempt in range(MAX_RETRIES + 1):
             try:
-                response = self._client.post(f"/api/v1/launches/{self._launch_id}/close")
+                response = self._client.post(
+                    f"/api/v1/launches/{self._launch_id}/close", json=body
+                )
                 if response.status_code in (200, 201, 204):
                     return
                 if response.status_code in RETRYABLE_STATUS_CODES and attempt < MAX_RETRIES:

charisma_cli-0.1.6/src/charisma_cli/watcher.py

@@ -0,0 +1,323 @@
+"""Watchdog observer, stability debounce, and file classification for allure-results."""
+
+import os
+import time
+from pathlib import Path
+from queue import PriorityQueue
+from threading import Lock, Timer
+
+from watchdog.events import FileSystemEvent, FileSystemEventHandler
+from watchdog.observers import Observer
+
+from charisma_cli.config import Config
+from charisma_cli.models import FileCategory, FileEvent
+
+_TWO_MB = 2 * 1024 * 1024
+_STABILITY_SECONDS = 0.5
+
+
+class _SeenSet:
+    """Thread-safe set of absolute paths already enqueued.
+
+    Shared by every producer (live observer, flush_pending, final_scan,
+    settle_scan) so each file is enqueued exactly once. ``add`` returns True
+    only the first time a path is seen, letting callers gate the enqueue.
+    """
+
+    def __init__(self) -> None:
+        self._paths: set[str] = set()
+        self._lock = Lock()
+
+    def add(self, path: str) -> bool:
+        """Record a path. Returns True if newly added, False if already present."""
+        with self._lock:
+            if path in self._paths:
+                return False
+            self._paths.add(path)
+            return True
+
+    def __contains__(self, path: str) -> bool:
+        with self._lock:
+            return path in self._paths
+
+
+def classify_file(filename: str) -> FileCategory | None:
+    """Classify a filename into a FileCategory or None if excluded.
+
+    Args:
+        filename: The base filename (not full path).
+
+    Returns:
+        FileCategory.RESULT for *-result.json,
+        FileCategory.CONTAINER for *-container.json,
+        FileCategory.ATTACHMENT for all other valid files,
+        None for excluded files (dot-prefix or .tmp suffix).
+    """
+    if filename.startswith("."):
+        return None
+    if filename.endswith(".tmp"):
+        return None
+    if filename.endswith("-result.json"):
+        return FileCategory.RESULT
+    if filename.endswith("-container.json"):
+        return FileCategory.CONTAINER
+    return FileCategory.ATTACHMENT
+
+
+def should_skip(path: Path, config: Config) -> bool:
+    """Check whether a file should be skipped based on size.
+
+    Args:
+        path: Path to the file on disk.
+        config: Resolved CLI configuration.
+
+    Returns:
+        True if the file exceeds 2MB and skip_too_big is enabled.
+    """
+    if not config.skip_too_big:
+        return False
+    return path.stat().st_size > _TWO_MB
+
+
+def _enqueue_once(
+    queue: "PriorityQueue[FileEvent]",
+    config: Config,
+    enqueued: "_SeenSet",
+    path: Path,
+    category: FileCategory,
+) -> bool:
+    """Enqueue a file exactly once, guarding all filesystem access.
+
+    Single owner of the enqueue-decision pipeline shared by every producer
+    (the live observer's debounce handler, flush_pending, and the scans):
+    resolve the path, apply the size-skip guard, gate on the shared seen-set,
+    then put the event. Keeping this in one place ensures the exactly-once
+    invariant (skip BEFORE marking seen, one canonical resolved-path key)
+    stays consistent across all callers.
+
+    All filesystem calls (``resolve``, ``stat`` via ``should_skip``) are guarded:
+    the scans run on the main thread during teardown, so an unhandled OSError
+    here would abort launch-close and the summary. On any filesystem error the
+    file is skipped rather than raised.
+
+    Returns:
+        True if a FileEvent was enqueued, False if skipped (too big, already
+        seen, or unreadable).
+    """
+    try:
+        if should_skip(path, config):
+            return False
+        abs_path = str(path.resolve())
+    except (OSError, ValueError):
+        # File vanished, permission/symlink error, or unresolvable path —
+        # skip it rather than crash the caller (main-thread teardown).
+        return False
+
+    if not enqueued.add(abs_path):
+        return False
+    queue.put(FileEvent(path=path, category=category))
+    return True
+
+
+class _StabilityHandler(FileSystemEventHandler):
+    """Debounces filesystem events, enqueuing files after 500ms of stability."""
+
+    def __init__(self, queue: "PriorityQueue[FileEvent]", config: Config, enqueued: "_SeenSet") -> None:
+        super().__init__()
+        self._queue = queue
+        self._config = config
+        self._timers: dict[str, Timer] = {}
+        # Shared across the live observer, flush_pending, and the scans so a
+        # given file is enqueued exactly once no matter which producer sees it
+        # first. Without this, the end-of-run settle_scan re-enqueues files the
+        # live observer already delivered, doubling results_sent.
+        self._enqueued = enqueued
+
+    def on_created(self, event: FileSystemEvent) -> None:
+        """Handle file creation events."""
+        if not event.is_directory:
+            self._handle_event(event.src_path)
+
+    def on_modified(self, event: FileSystemEvent) -> None:
+        """Handle file modification events."""
+        if not event.is_directory:
+            self._handle_event(event.src_path)
+
+    def _handle_event(self, src_path: str) -> None:
+        """Reset the stability timer for a file path."""
+        path = Path(src_path)
+        filename = path.name
+
+        category = classify_file(filename)
+        if category is None:
+            return
+
+        # Cancel existing timer for this path
+        existing = self._timers.get(src_path)
+        if existing is not None:
+            existing.cancel()
+
+        # Set a new timer that enqueues after stability period
+        timer = Timer(_STABILITY_SECONDS, self._enqueue, args=(path, category))
+        timer.daemon = True
+        self._timers[src_path] = timer
+        timer.start()
+
+    def _enqueue(self, path: Path, category: FileCategory) -> None:
+        """Enqueue a file event after stability check passes."""
+        # Remove from timer dict
+        self._timers.pop(str(path), None)
+        _enqueue_once(self._queue, self._config, self._enqueued, path, category)
+
+    def cancel_all(self) -> None:
+        """Cancel all pending timers."""
+        for timer in self._timers.values():
+            timer.cancel()
+        self._timers.clear()
+
+    def flush_pending(self) -> None:
+        """Immediately enqueue all files currently in debounce windows.
+
+        Called after subprocess exit to ensure no result files are lost due
+        to pending debounce timers. Cancels all timers and enqueues their
+        associated files directly.
+        """
+        # Snapshot and clear timers atomically
+        pending = dict(self._timers)
+        self._timers.clear()
+
+        for src_path, timer in pending.items():
+            timer.cancel()
+            path = Path(src_path)
+
+            category = classify_file(path.name)
+            if category is None:
+                continue
+
+            _enqueue_once(self._queue, self._config, self._enqueued, path, category)
+
+
+class ResultsWatcher:
+    """Watches the allure-results directory for new files using watchdog.
+
+    Creates the directory if it doesn't exist, observes file creation/modification,
+    debounces events for 500ms of stability, then enqueues FileEvent objects
+    into the provided PriorityQueue.
+    """
+
+    def __init__(self, results_dir: str, queue: "PriorityQueue[FileEvent]", config: Config) -> None:
+        self._results_dir = results_dir
+        self._queue = queue
+        self._config = config
+        # One shared seen-set gates every producer (live observer, flush_pending,
+        # final_scan, settle_scan) so each file is enqueued exactly once.
+        self._enqueued = _SeenSet()
+        self._handler = _StabilityHandler(queue, config, self._enqueued)
+        self._observer = Observer()
+
+    def start(self) -> None:
+        """Create the results directory and start observing for file events."""
+        os.makedirs(self._results_dir, exist_ok=True)
+        self._observer.schedule(self._handler, self._results_dir, recursive=False)
+        self._observer.start()
+
+    def stop(self) -> None:
+        """Stop the observer and cancel all pending stability timers."""
+        self._observer.stop()
+        self._observer.join()
+        self._handler.cancel_all()
+
+    def flush_pending(self) -> None:
+        """Flush all files currently in debounce windows into the queue.
+
+        Should be called BEFORE stop() when you want to capture all pending
+        files rather than discard them.
+        """
+        self._handler.flush_pending()
+
+    def final_scan(self) -> int:
+        """Scan the results directory and enqueue any files not already processed.
+
+        Performs a one-time sweep of all files in the results directory,
+        enqueuing any that pass classification and size checks. This catches
+        files that the filesystem watcher may have missed entirely (e.g., written
+        between watcher setup and observation start, or during high-throughput
+        bursts that overwhelm OS event buffers). Files already enqueued by any
+        producer are skipped via the shared seen-set.
+
+        Runs on the main thread during teardown, so all filesystem access is
+        guarded: a transient error listing or reading a file skips that file
+        rather than aborting the scan (and the launch-close that follows it).
+
+        Returns:
+            Number of new files enqueued by this scan.
+        """
+        results_path = Path(self._results_dir)
+        try:
+            entries = list(results_path.iterdir())
+        except (OSError, FileNotFoundError):
+            # Directory missing or unreadable — nothing to enqueue this pass.
+            return 0
+
+        enqueued = 0
+        for filepath in entries:
+            try:
+                if not filepath.is_file():
+                    continue
+            except OSError:
+                continue
+
+            category = classify_file(filepath.name)
+            if category is None:
+                continue
+
+            if _enqueue_once(self._queue, self._config, self._enqueued, filepath, category):
+                enqueued += 1
+
+        return enqueued
+
+    def settle_scan(
+        self,
+        quiet_period: float = 1.0,
+        max_wait: float = 15.0,
+        poll_interval: float = 0.25,
+    ) -> int:
+        """Repeatedly scan until the results directory stops producing new files.
+
+        Under high parallelism (e.g. pytest-xdist with many workers), allure
+        writes its result files in a burst during the test process's teardown.
+        A single ``final_scan()`` taken the instant the subprocess exits can run
+        before the OS has finished flushing that burst to disk, capturing zero
+        or a partial set — the ``watch results_sent=0`` bug. This method keeps
+        scanning until no new files have appeared for ``quiet_period`` seconds
+        (the directory has "settled"), or until ``max_wait`` seconds elapse.
+
+        Idempotent with ``final_scan()``: both share the watcher's internal
+        ``_enqueued`` set, so files already enqueued are never enqueued again.
+
+        Args:
+            quiet_period: Seconds with no new files before the directory is
+                considered settled.
+            max_wait: Absolute cap on total wait time, so a directory that keeps
+                changing can't block teardown forever.
+            poll_interval: Delay between scans.
+
+        Returns:
+            Total number of new files enqueued across all iterations.
+        """
+        total = 0
+        deadline = time.monotonic() + max_wait
+        last_new_at = time.monotonic()
+
+        while time.monotonic() < deadline:
+            new_count = self.final_scan()
+            total += new_count
+            now = time.monotonic()
+            if new_count > 0:
+                last_new_at = now
+            elif now - last_new_at >= quiet_period:
+                # No new files for a full quiet period — directory has settled.
+                break
+            time.sleep(poll_interval)
+
+        return total

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

@@ -170,3 +170,75 @@ class TestUploadCommand:
 
         assert result.exit_code == 0
         assert "results_sent" in result.output or "Summary" in result.output or result.exit_code == 0
+
+
+class TestReportingFixesEndToEnd:
+    """E2E: skipped tests are sent, and environment.properties → close variables."""
+
+    @respx.mock
+    def test_skipped_result_and_variables_are_sent(self, tmp_path: Path, monkeypatch) -> None:
+        """A skipped result (no 'stop') is uploaded, and environment.properties
+        is sent as `variables` in the close-launch body."""
+        results_dir = tmp_path / "allure-results"
+        results_dir.mkdir()
+
+        # Skipped result — no "stop" (Allure omits it for tests that never ran)
+        (results_dir / "skip-result.json").write_text(json.dumps({
+            "uuid": "skip-1",
+            "historyId": "hist_skip",
+            "fullName": "tests.test_x.test_skipped",
+            "name": "test_skipped",
+            "status": "skipped",
+            "statusDetails": {"message": "conditional skip"},
+            "start": 1000,
+            "labels": [],
+            "parameters": [],
+        }))
+
+        # Allure environment.properties → launch variables
+        (results_dir / "environment.properties").write_text(
+            "environment_name=dv1\naws_region=us-west-2\nworkers_number=8\n"
+        )
+
+        respx.post("https://charisma.test/api/v1/launches").mock(
+            return_value=httpx.Response(
+                201, json={"launchId": "launch-x", "projectId": "proj-uuid"}
+            )
+        )
+        results_route = respx.post(
+            "https://charisma.test/api/v1/launches/launch-x/results"
+        ).mock(return_value=httpx.Response(200, json={"accepted": 1}))
+        close_route = respx.post(
+            "https://charisma.test/api/v1/launches/launch-x/close"
+        ).mock(return_value=httpx.Response(200, json={}))
+
+        monkeypatch.setenv("CHARISMA_ENDPOINT", "https://charisma.test")
+        monkeypatch.setenv("CHARISMA_TOKEN", "tok")
+
+        runner = CliRunner()
+        result = runner.invoke(cli, [
+            "watch",
+            "--project", "p",
+            "--results", str(results_dir),
+            "--", sys.executable, "-c", "import sys; sys.exit(0)",
+        ])
+
+        assert result.exit_code == 0
+
+        # 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}
+        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")
+        assert skip_payload["duration_ms"] == 0
+
+        # environment.properties sent as variables on close
+        assert close_route.called
+        close_body = json.loads(close_route.calls[0].request.content)
+        assert close_body["variables"] == {
+            "environment_name": "dv1",
+            "aws_region": "us-west-2",
+            "workers_number": "8",
+        }

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

@@ -216,8 +216,12 @@ class TestParseResultFile:
 
         assert result is None
 
-    def test_missing_start_stop_returns_none(self, tmp_path: Path) -> None:
-        """Result without timing fields cannot compute duration → returns None."""
+    def test_missing_start_stop_parses_with_zero_duration(self, tmp_path: Path) -> None:
+        """Result without timing fields parses with duration 0 (not dropped).
+
+        Previously this returned None, which silently dropped skipped tests
+        (Allure omits 'stop' for tests that never executed).
+        """
         data = {
             "uuid": "no-time",
             "historyId": "hist",
@@ -227,7 +231,10 @@ class TestParseResultFile:
         filepath = self._write_json(tmp_path, data)
         result = parse_result_file(filepath)
 
-        assert result is None
+        assert result is not None
+        assert result.duration_ms == 0
+        assert result.started_at is None
+        assert result.ended_at is None
 
     def test_nonexistent_file_returns_none(self, tmp_path: Path) -> None:
         """File that doesn't exist returns None gracefully."""
@@ -534,3 +541,111 @@ class TestExtractAttachmentRefs:
 
         assert len(refs) == 1
         assert refs[0].name == "abc-screenshot.png"
+
+
+class TestSkippedResultParsing:
+    """Regression: skipped tests (no 'stop', sometimes no 'start') must parse.
+
+    Allure omits 'stop' for tests that never executed (skipped). The parser
+    previously required both start and stop and returned None, silently
+    dropping skipped results so they never reached Charisma.
+    """
+
+    def test_skipped_without_stop_parses(self, tmp_path: Path) -> None:
+        """A skipped result with 'start' but no 'stop' parses with duration 0."""
+        filepath = tmp_path / "skip-result.json"
+        filepath.write_text(json.dumps({
+            "uuid": "skip-uuid",
+            "historyId": "hist-skip",
+            "fullName": "tests.test_mod.test_skipped",
+            "name": "test_skipped",
+            "status": "skipped",
+            "statusDetails": {"message": "conditional skip"},
+            "start": 1000,
+            # no "stop"
+            "labels": [],
+            "parameters": [],
+        }))
+
+        result = parse_result_file(filepath)
+
+        assert result is not None
+        assert result.outcome == "skipped"
+        assert result.duration_ms == 0
+        assert result.testId == "hist-skip"
+        assert result.error_message == "conditional skip"
+
+    def test_skipped_without_start_or_stop_parses(self, tmp_path: Path) -> None:
+        """A skipped result with neither start nor stop still parses."""
+        filepath = tmp_path / "skip2-result.json"
+        filepath.write_text(json.dumps({
+            "uuid": "skip2-uuid",
+            "fullName": "tests.test_mod.test_skipped2",
+            "status": "skipped",
+            "labels": [],
+            "parameters": [],
+        }))
+
+        result = parse_result_file(filepath)
+
+        assert result is not None
+        assert result.outcome == "skipped"
+        assert result.duration_ms == 0
+        assert result.started_at is None
+        assert result.ended_at is None
+
+    def test_missing_uuid_still_returns_none(self, tmp_path: Path) -> None:
+        """uuid remains strictly required — its absence returns None."""
+        filepath = tmp_path / "nouuid-result.json"
+        filepath.write_text(json.dumps({
+            "fullName": "tests.test_mod.test_x",
+            "status": "passed",
+            "start": 1000,
+            "stop": 2000,
+        }))
+
+        assert parse_result_file(filepath) is None
+
+
+class TestParseEnvironmentProperties:
+    """parse_environment_properties reads Allure environment.properties files."""
+
+    def test_parses_key_value_pairs(self, tmp_path: Path) -> None:
+        from charisma_cli.parser import parse_environment_properties
+
+        f = tmp_path / "environment.properties"
+        f.write_text(
+            "environment_name=dv1\n"
+            "aws_region=us-west-2\n"
+            "workers_number=8\n"
+        )
+        result = parse_environment_properties(f)
+        assert result == {
+            "environment_name": "dv1",
+            "aws_region": "us-west-2",
+            "workers_number": "8",
+        }
+
+    def test_ignores_comments_and_blank_lines(self, tmp_path: Path) -> None:
+        from charisma_cli.parser import parse_environment_properties
+
+        f = tmp_path / "environment.properties"
+        f.write_text(
+            "# a comment\n"
+            "! another comment\n"
+            "\n"
+            "key=value\n"
+        )
+        assert parse_environment_properties(f) == {"key": "value"}
+
+    def test_value_with_equals_sign_keeps_remainder(self, tmp_path: Path) -> None:
+        from charisma_cli.parser import parse_environment_properties
+
+        f = tmp_path / "environment.properties"
+        f.write_text("url=https://x.com/a?b=c\n")
+        assert parse_environment_properties(f) == {"url": "https://x.com/a?b=c"}
+
+    def test_missing_file_returns_empty(self, tmp_path: Path) -> None:
+        from charisma_cli.parser import parse_environment_properties
+
+        assert parse_environment_properties(tmp_path / "nope.properties") == {}

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

@@ -520,8 +520,12 @@ class TestFinalScan:
         event = queue.get_nowait()
         assert event.path.name == "valid-result.json"
 
-    def test_skips_already_seen_files(self, tmp_path: Path) -> None:
-        """final_scan skips files in the already_seen set."""
+    def test_skips_files_already_enqueued(self, tmp_path: Path) -> None:
+        """final_scan skips files already enqueued by a prior producer.
+
+        Dedup is via the watcher's shared seen-set: a file the live observer
+        already claimed is not re-enqueued by a subsequent scan.
+        """
         results_dir = tmp_path / "allure-results"
         results_dir.mkdir()
 
@@ -534,8 +538,11 @@ class TestFinalScan:
         config = _make_config()
         watcher = ResultsWatcher(str(results_dir), queue, config)
 
-        already_seen = {str(file_a.resolve())}
-        count = watcher.final_scan(already_seen=already_seen)
+        # Simulate file_a already enqueued via the live-observer path.
+        watcher._handler._enqueue(file_a, FileCategory.RESULT)
+        queue.get_nowait()  # drain the observer's enqueue
+
+        count = watcher.final_scan()
 
         assert count == 1
         event = queue.get_nowait()
@@ -569,3 +576,230 @@ class TestFinalScan:
 
         assert count == 0
         assert queue.empty()
+
+
+# ---------------------------------------------------------------------------
+# settle_scan() tests — the fix for the `watch results_sent=0` bug under
+# high pytest-xdist parallelism (burst of result files written at teardown).
+# ---------------------------------------------------------------------------
+
+
+class TestSettleScan:
+    """settle_scan rescans until the results directory stops changing.
+
+    A single final_scan() taken the instant the test subprocess exits can run
+    before the OS finishes flushing allure's end-of-session burst, capturing
+    nothing (the results_sent=0 bug). settle_scan keeps scanning until the
+    directory is quiet, so the whole burst is captured regardless of how many
+    files or workers produced it.
+    """
+
+    def test_captures_files_present_before_scan(self, tmp_path: Path) -> None:
+        """Files already on disk are enqueued by the first settle_scan pass."""
+        results_dir = tmp_path / "allure-results"
+        results_dir.mkdir()
+        for i in range(5):
+            (results_dir / f"r{i}-result.json").write_text("{}")
+
+        queue: PriorityQueue = PriorityQueue()
+        watcher = ResultsWatcher(str(results_dir), queue, _make_config())
+
+        enqueued = watcher.settle_scan(quiet_period=0.3, max_wait=3.0, poll_interval=0.1)
+
+        assert enqueued == 5
+        assert queue.qsize() == 5
+
+    def test_captures_single_result_flushed_after_first_scan(self, tmp_path: Path) -> None:
+        """Single-test case: one result file flushed AFTER the initial scan.
+
+        Reproduces the observed 1-test / 1-worker `results_sent=0` failure —
+        allure-pytest flushes its one result file during process teardown, which
+        surfaces to the filesystem just after the subprocess exits. A single
+        final_scan taken at that instant captures 0; settle_scan waits and
+        captures the 1 late file. This is the N=1 boundary of the burst race.
+        """
+        import threading
+
+        results_dir = tmp_path / "allure-results"
+        results_dir.mkdir()
+
+        queue: PriorityQueue = PriorityQueue()
+        watcher = ResultsWatcher(str(results_dir), queue, _make_config())
+
+        def write_single_late() -> None:
+            time.sleep(0.3)
+            (results_dir / "only-result.json").write_text("{}")
+
+        writer = threading.Thread(target=write_single_late)
+        writer.start()
+
+        # Directory is empty when the first scan runs (the old bug: captures 0).
+        first = watcher.final_scan()
+        assert first == 0
+
+        settled = watcher.settle_scan(quiet_period=0.5, max_wait=10.0, poll_interval=0.1)
+        writer.join()
+
+        assert first + settled == 1
+        assert queue.qsize() == 1
+
+    def test_captures_burst_written_after_first_scan(self, tmp_path: Path) -> None:
+        """The core fix: files that appear AFTER the initial scan are still captured.
+
+        Reproduces the teardown-burst race — a single final_scan would have
+        captured only the one baseline file; settle_scan waits for the rest.
+        """
+        import threading
+
+        results_dir = tmp_path / "allure-results"
+        results_dir.mkdir()
+        (results_dir / "baseline-result.json").write_text("{}")
+
+        queue: PriorityQueue = PriorityQueue()
+        watcher = ResultsWatcher(str(results_dir), queue, _make_config())
+
+        def write_burst() -> None:
+            time.sleep(0.2)
+            for i in range(30):
+                (results_dir / f"burst{i}-result.json").write_text("{}")
+                time.sleep(0.02)
+
+        writer = threading.Thread(target=write_burst)
+        writer.start()
+
+        # A single scan would see only the baseline file.
+        first = watcher.final_scan()
+        assert first == 1
+
+        # settle_scan reconciles the burst that lands afterward.
+        settled = watcher.settle_scan(quiet_period=0.5, max_wait=10.0, poll_interval=0.1)
+        writer.join()
+
+        assert first + settled == 31
+        assert queue.qsize() == 31
+
+    def test_no_duplicate_enqueue_across_scans(self, tmp_path: Path) -> None:
+        """Repeated scans never enqueue the same file twice (shared seen-set)."""
+        results_dir = tmp_path / "allure-results"
+        results_dir.mkdir()
+        for i in range(4):
+            (results_dir / f"r{i}-result.json").write_text("{}")
+
+        queue: PriorityQueue = PriorityQueue()
+        watcher = ResultsWatcher(str(results_dir), queue, _make_config())
+
+        first = watcher.settle_scan(quiet_period=0.3, max_wait=3.0, poll_interval=0.1)
+        second = watcher.settle_scan(quiet_period=0.3, max_wait=3.0, poll_interval=0.1)
+
+        assert first == 4
+        assert second == 0  # nothing new — no double-enqueue
+        assert queue.qsize() == 4
+
+    def test_observer_enqueue_and_settle_scan_dedup(self, tmp_path: Path) -> None:
+        """Files the live observer already enqueued are not re-enqueued by settle_scan.
+
+        The live-observer path (_StabilityHandler._enqueue) and settle_scan share
+        the watcher's seen-set. Without this, settle_scan would double-count files
+        the observer already delivered — the results_sent doubling regression.
+        """
+        results_dir = tmp_path / "allure-results"
+        results_dir.mkdir()
+        files = []
+        for i in range(10):
+            f = results_dir / f"r{i}-result.json"
+            f.write_text("{}")
+            files.append(f)
+
+        queue: PriorityQueue = PriorityQueue()
+        watcher = ResultsWatcher(str(results_dir), queue, _make_config())
+
+        # Simulate the live observer having already enqueued the first 4 files
+        # by driving the handler's enqueue path directly.
+        for f in files[:4]:
+            watcher._handler._enqueue(f, FileCategory.RESULT)
+        assert queue.qsize() == 4
+
+        # settle_scan should add only the remaining 6, not re-add the first 4.
+        added = watcher.settle_scan(quiet_period=0.3, max_wait=3.0, poll_interval=0.1)
+
+        assert added == 6
+        assert queue.qsize() == 10  # 10 unique, zero duplicates
+
+        seen: set[str] = set()
+        while not queue.empty():
+            ev: FileEvent = queue.get_nowait()
+            key = str(ev.path.resolve())
+            assert key not in seen, "duplicate file enqueued"
+            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."""
+        results_dir = tmp_path / "allure-results"
+        results_dir.mkdir()
+
+        queue: PriorityQueue = PriorityQueue()
+        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)
+        elapsed = time.monotonic() - start
+
+        assert enqueued == 0
+        assert queue.empty()
+        assert elapsed < 4.0  # returned on the quiet-period, not the max_wait cap
+
+    def test_respects_max_wait_when_directory_never_settles(self, tmp_path: Path) -> 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.
+        """
+        import threading
+
+        results_dir = tmp_path / "allure-results"
+        results_dir.mkdir()
+
+        queue: PriorityQueue = PriorityQueue()
+        watcher = ResultsWatcher(str(results_dir), queue, _make_config())
+
+        stop = threading.Event()
+
+        def write_forever() -> None:
+            i = 0
+            while not stop.is_set():
+                (results_dir / f"c{i}-result.json").write_text("{}")
+                i += 1
+                time.sleep(0.05)
+
+        writer = threading.Thread(target=write_forever)
+        writer.start()
+        try:
+            start = time.monotonic()
+            watcher.settle_scan(quiet_period=0.5, max_wait=1.5, poll_interval=0.1)
+            elapsed = time.monotonic() - start
+        finally:
+            stop.set()
+            writer.join()
+
+        # Should stop at ~max_wait, not run indefinitely.
+        assert 1.5 <= elapsed < 4.0
+
+    def test_scales_to_large_burst(self, tmp_path: Path) -> None:
+        """A large number of files (simulating many workers/tests) is fully captured.
+
+        Correctness is independent of file count — settle_scan keeps scanning
+        until quiet, so 500 files enqueue exactly once each.
+        """
+        results_dir = tmp_path / "allure-results"
+        results_dir.mkdir()
+        for i in range(500):
+            (results_dir / f"r{i}-result.json").write_text("{}")
+
+        queue: PriorityQueue = PriorityQueue()
+        watcher = ResultsWatcher(str(results_dir), queue, _make_config())
+
+        enqueued = watcher.settle_scan(quiet_period=0.3, max_wait=10.0, poll_interval=0.1)
+
+        assert enqueued == 500
+        assert queue.qsize() == 500

charisma_cli-0.1.4/src/charisma_cli/watcher.py

@@ -1,223 +0,0 @@
-"""Watchdog observer, stability debounce, and file classification for allure-results."""
-
-import os
-from pathlib import Path
-from queue import PriorityQueue
-from threading import Timer
-
-from watchdog.events import FileSystemEvent, FileSystemEventHandler
-from watchdog.observers import Observer
-
-from charisma_cli.config import Config
-from charisma_cli.models import FileCategory, FileEvent
-
-_TWO_MB = 2 * 1024 * 1024
-_STABILITY_SECONDS = 0.5
-
-
-def classify_file(filename: str) -> FileCategory | None:
-    """Classify a filename into a FileCategory or None if excluded.
-
-    Args:
-        filename: The base filename (not full path).
-
-    Returns:
-        FileCategory.RESULT for *-result.json,
-        FileCategory.CONTAINER for *-container.json,
-        FileCategory.ATTACHMENT for all other valid files,
-        None for excluded files (dot-prefix or .tmp suffix).
-    """
-    if filename.startswith("."):
-        return None
-    if filename.endswith(".tmp"):
-        return None
-    if filename.endswith("-result.json"):
-        return FileCategory.RESULT
-    if filename.endswith("-container.json"):
-        return FileCategory.CONTAINER
-    return FileCategory.ATTACHMENT
-
-
-def should_skip(path: Path, config: Config) -> bool:
-    """Check whether a file should be skipped based on size.
-
-    Args:
-        path: Path to the file on disk.
-        config: Resolved CLI configuration.
-
-    Returns:
-        True if the file exceeds 2MB and skip_too_big is enabled.
-    """
-    if not config.skip_too_big:
-        return False
-    return path.stat().st_size > _TWO_MB
-
-
-class _StabilityHandler(FileSystemEventHandler):
-    """Debounces filesystem events, enqueuing files after 500ms of stability."""
-
-    def __init__(self, queue: PriorityQueue, config: Config) -> None:
-        super().__init__()
-        self._queue = queue
-        self._config = config
-        self._timers: dict[str, Timer] = {}
-
-    def on_created(self, event: FileSystemEvent) -> None:
-        """Handle file creation events."""
-        if not event.is_directory:
-            self._handle_event(event.src_path)
-
-    def on_modified(self, event: FileSystemEvent) -> None:
-        """Handle file modification events."""
-        if not event.is_directory:
-            self._handle_event(event.src_path)
-
-    def _handle_event(self, src_path: str) -> None:
-        """Reset the stability timer for a file path."""
-        path = Path(src_path)
-        filename = path.name
-
-        category = classify_file(filename)
-        if category is None:
-            return
-
-        # Cancel existing timer for this path
-        existing = self._timers.get(src_path)
-        if existing is not None:
-            existing.cancel()
-
-        # Set a new timer that enqueues after stability period
-        timer = Timer(_STABILITY_SECONDS, self._enqueue, args=(path, category))
-        timer.daemon = True
-        self._timers[src_path] = timer
-        timer.start()
-
-    def _enqueue(self, path: Path, category: FileCategory) -> None:
-        """Enqueue a file event after stability check passes."""
-        # Remove from timer dict
-        self._timers.pop(str(path), None)
-
-        # Check file still exists and size at enqueue time
-        try:
-            if should_skip(path, self._config):
-                return
-        except (OSError, FileNotFoundError):
-            return  # File was deleted between debounce and enqueue
-
-        self._queue.put(FileEvent(path=path, category=category))
-
-    def cancel_all(self) -> None:
-        """Cancel all pending timers."""
-        for timer in self._timers.values():
-            timer.cancel()
-        self._timers.clear()
-
-    def flush_pending(self) -> None:
-        """Immediately enqueue all files currently in debounce windows.
-
-        Called after subprocess exit to ensure no result files are lost due
-        to pending debounce timers. Cancels all timers and enqueues their
-        associated files directly.
-        """
-        # Snapshot and clear timers atomically
-        pending = dict(self._timers)
-        self._timers.clear()
-
-        for src_path, timer in pending.items():
-            timer.cancel()
-            path = Path(src_path)
-            filename = path.name
-
-            category = classify_file(filename)
-            if category is None:
-                continue
-
-            try:
-                if should_skip(path, self._config):
-                    continue
-            except (OSError, FileNotFoundError):
-                continue
-
-            self._queue.put(FileEvent(path=path, category=category))
-
-
-class ResultsWatcher:
-    """Watches the allure-results directory for new files using watchdog.
-
-    Creates the directory if it doesn't exist, observes file creation/modification,
-    debounces events for 500ms of stability, then enqueues FileEvent objects
-    into the provided PriorityQueue.
-    """
-
-    def __init__(self, results_dir: str, queue: PriorityQueue, config: Config) -> None:
-        self._results_dir = results_dir
-        self._queue = queue
-        self._config = config
-        self._handler = _StabilityHandler(queue, config)
-        self._observer = Observer()
-
-    def start(self) -> None:
-        """Create the results directory and start observing for file events."""
-        os.makedirs(self._results_dir, exist_ok=True)
-        self._observer.schedule(self._handler, self._results_dir, recursive=False)
-        self._observer.start()
-
-    def stop(self) -> None:
-        """Stop the observer and cancel all pending stability timers."""
-        self._observer.stop()
-        self._observer.join()
-        self._handler.cancel_all()
-
-    def flush_pending(self) -> None:
-        """Flush all files currently in debounce windows into the queue.
-
-        Should be called BEFORE stop() when you want to capture all pending
-        files rather than discard them.
-        """
-        self._handler.flush_pending()
-
-    def final_scan(self, already_seen: set[str] | None = None) -> int:
-        """Scan the results directory and enqueue any files not already processed.
-
-        Performs a one-time sweep of all files in the results directory,
-        enqueuing any that pass classification and size checks. This catches
-        files that the filesystem watcher may have missed entirely (e.g., written
-        between watcher setup and observation start, or during high-throughput
-        bursts that overwhelm OS event buffers).
-
-        Args:
-            already_seen: Optional set of absolute path strings that were
-                already enqueued. Files in this set are skipped.
-
-        Returns:
-            Number of new files enqueued by this scan.
-        """
-        results_path = Path(self._results_dir)
-        if not results_path.exists():
-            return 0
-
-        enqueued = 0
-        seen = already_seen or set()
-
-        for filepath in results_path.iterdir():
-            if not filepath.is_file():
-                continue
-
-            abs_path = str(filepath.resolve())
-            if abs_path in seen:
-                continue
-
-            category = classify_file(filepath.name)
-            if category is None:
-                continue
-
-            try:
-                if should_skip(filepath, self._config):
-                    continue
-            except (OSError, FileNotFoundError):
-                continue
-
-            self._queue.put(FileEvent(path=filepath, category=category))
-            enqueued += 1
-
-        return enqueued