charisma-cli 0.1.2__tar.gz → 0.1.5__tar.gz

{charisma_cli-0.1.2 → charisma_cli-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: charisma-cli
-Version: 0.1.2
+Version: 0.1.5
 Summary: CLI tool that watches allure-results and streams test results + attachments to Charisma.
 Author: Charisma Team
 License-Expression: MIT
@@ -41,18 +41,6 @@ For local development from a checkout of the repo:
 pip install -e packages/charisma-cli
 ```
 
-<details>
-<summary>Alternative: install from the GitHub Packages registry (PyOCI)</summary>
-
-Also published to GitHub Packages via [PyOCI](https://pyoci.com) (requires a GitHub token with `read:packages`) — useful for a build not yet on PyPI:
-
-```bash
-pip install charisma-cli \
-  --index-url "https://__token__:$GITHUB_TOKEN@pyoci.com/ghcr.io/align-QCOE/"
-```
-
-</details>
-
 ## Publishing (maintainers)
 
 Releases publish to public PyPI automatically from the merge-queue workflow using a **PyPI API token**.
@@ -96,3 +84,22 @@ charismactl watch --results allure-results -- uv run pytest -n 4 tests/
 | `--project ID`   | Project alias (overrides env var)            |
 | `--silent`       | Don't fail pipeline if upload errors occur   |
 | `--skip-too-big` | Skip result files larger than 2MB            |
+
+## Launch URL in CI
+
+`charismactl` prints the Charisma launch URL (`Charisma launch: <url>`) and, when running
+in GitHub Actions, writes it as a step output named `launch_url`. Attach it to the job
+summary or a Teams message:
+
+```yaml
+- name: Run tests and stream to Charisma
+  id: charisma
+  run: charismactl watch --project my-project -- pytest tests/
+
+- name: Add Charisma link to summary
+  if: always()
+  run: echo "[View Charisma launch](${{ steps.charisma.outputs.launch_url }})" >> "$GITHUB_STEP_SUMMARY"
+
+# The same value can feed a Teams-notification step:
+#   text: "Results: ${{ steps.charisma.outputs.launch_url }}"
+```

{charisma_cli-0.1.2 → charisma_cli-0.1.5}/README.md

@@ -16,18 +16,6 @@ For local development from a checkout of the repo:
 pip install -e packages/charisma-cli
 ```
 
-<details>
-<summary>Alternative: install from the GitHub Packages registry (PyOCI)</summary>
-
-Also published to GitHub Packages via [PyOCI](https://pyoci.com) (requires a GitHub token with `read:packages`) — useful for a build not yet on PyPI:
-
-```bash
-pip install charisma-cli \
-  --index-url "https://__token__:$GITHUB_TOKEN@pyoci.com/ghcr.io/align-QCOE/"
-```
-
-</details>
-
 ## Publishing (maintainers)
 
 Releases publish to public PyPI automatically from the merge-queue workflow using a **PyPI API token**.
@@ -71,3 +59,22 @@ charismactl watch --results allure-results -- uv run pytest -n 4 tests/
 | `--project ID`   | Project alias (overrides env var)            |
 | `--silent`       | Don't fail pipeline if upload errors occur   |
 | `--skip-too-big` | Skip result files larger than 2MB            |
+
+## Launch URL in CI
+
+`charismactl` prints the Charisma launch URL (`Charisma launch: <url>`) and, when running
+in GitHub Actions, writes it as a step output named `launch_url`. Attach it to the job
+summary or a Teams message:
+
+```yaml
+- name: Run tests and stream to Charisma
+  id: charisma
+  run: charismactl watch --project my-project -- pytest tests/
+
+- name: Add Charisma link to summary
+  if: always()
+  run: echo "[View Charisma launch](${{ steps.charisma.outputs.launch_url }})" >> "$GITHUB_STEP_SUMMARY"
+
+# The same value can feed a Teams-notification step:
+#   text: "Results: ${{ steps.charisma.outputs.launch_url }}"
+```

{charisma_cli-0.1.2 → charisma_cli-0.1.5}/pyproject.toml

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

charisma_cli-0.1.5/src/charisma_cli/launch_url.py

@@ -0,0 +1,45 @@
+"""Construct and surface the Charisma launch URL for CI consumption."""
+
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+# The Charisma web UI base is always the same, unlike the region-dependent API
+# ingestion endpoint. Hardcoded here rather than exposed as user config.
+WEB_BASE_URL = "https://charisma.aligntech.com"
+
+
+def build_launch_url(project_id: str, launch_id: str) -> str:
+    """Build the Charisma web URL for a launch.
+
+    Mirrors the frontend route ``/project/{projectId}/launches/{launchId}``.
+
+    Args:
+        project_id: Project UUID (from the open-launch API response).
+        launch_id: Launch UUID.
+
+    Returns:
+        The fully-qualified launch URL.
+    """
+    return f"{WEB_BASE_URL}/project/{project_id}/launches/{launch_id}"
+
+
+def emit_github_output(launch_url: str) -> None:
+    """Append ``launch_url=<url>`` to the GitHub Actions step output file.
+
+    No-op when not running under GitHub Actions (``GITHUB_OUTPUT`` unset).
+    Failures are logged and swallowed — surfacing the URL must never affect
+    the exit code or upload outcome.
+
+    Args:
+        launch_url: The launch URL to expose as the ``launch_url`` step output.
+    """
+    github_output = os.getenv("GITHUB_OUTPUT")
+    if not github_output:
+        return
+    try:
+        with open(github_output, "a", encoding="utf-8") as fh:
+            fh.write(f"launch_url={launch_url}\n")
+    except OSError as e:
+        logger.warning("Could not write launch_url to GITHUB_OUTPUT: %s", e)

{charisma_cli-0.1.2 → charisma_cli-0.1.5}/src/charisma_cli/main.py

@@ -9,7 +9,9 @@ import click
 
 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
@@ -59,6 +61,57 @@ 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.
+
+    Constructs the URL from the project UUID returned by the open-launch
+    response and the launch ID. Prints it to stdout and, when running under
+    GitHub Actions, appends ``launch_url=<url>`` to $GITHUB_OUTPUT.
+    Does nothing if no launch was opened or the project UUID is unavailable.
+    """
+    launch_id = uploader.launch_id
+    project_id = uploader.project_id
+    if not launch_id or not project_id:
+        return
+    url = build_launch_url(project_id, launch_id)
+    click.echo(f"Charisma launch: {url}")
+    emit_github_output(url)
+
+
+def _warn_if_results_unsent(uploader: Uploader, config: Config) -> None:
+    """Warn loudly when result files exist on disk but none were sent.
+
+    Turns the previously-silent ``results_sent=0`` failure into a visible
+    warning naming the absolute watched path and the on-disk result count, so
+    a broken run is not mistaken for success.
+    """
+    if uploader.summary.results_sent > 0:
+        return
+    results_path = Path(config.results_dir).resolve()
+    if not results_path.exists():
+        return
+    result_files = [p for p in results_path.iterdir() if p.name.endswith("-result.json")]
+    if result_files:
+        click.echo(
+            f"Warning: {len(result_files)} result file(s) present in "
+            f"{results_path} but results_sent=0 — nothing was uploaded. "
+            "Check connectivity/auth or file another issue.",
+            err=True,
+        )
+
+
 def _print_summary(uploader: Uploader) -> None:
     """Print the upload summary to stdout."""
     summary = uploader.summary
@@ -106,6 +159,9 @@ def watch(
         mgr.spawn(command)
         sys.exit(mgr.wait())
 
+    # Surface the launch URL (stdout + $GITHUB_OUTPUT) now that the launch is open
+    _surface_launch_url(uploader)
+
     # Start watcher + uploader consumer
     watcher = ResultsWatcher(config.results_dir, queue, config)
     watcher.start()
@@ -141,11 +197,12 @@ 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
 
+    _warn_if_results_unsent(uploader, config)
     _print_summary(uploader)
     sys.exit(exit_code)
 
@@ -181,6 +238,9 @@ def upload(
         click.echo("Warning: Failed to open launch. No results uploaded.", err=True)
         sys.exit(0)
 
+    # Surface the launch URL (stdout + $GITHUB_OUTPUT) now that the launch is open
+    _surface_launch_url(uploader)
+
     # Scan existing results directory
     results_path = Path(config.results_dir)
     if not results_path.exists():
@@ -200,7 +260,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.2 → charisma_cli-0.1.5}/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.2 → charisma_cli-0.1.5}/src/charisma_cli/uploader.py

@@ -51,10 +51,12 @@ class Uploader:
         self._queue = queue
         self._summary = UploadSummary()
         self._launch_id: str | None = None
+        self._project_id: str | None = None
         self._disabled = False
         self._auth_failed = False
         self._stop_event = threading.Event()
         self._drain_event = threading.Event()
+        self._batch_lock = threading.Lock()
         self._thread: threading.Thread | None = None
         self._client: httpx.Client | None = None
         self._batch: list[dict[str, Any]] = []
@@ -69,6 +71,16 @@ class Uploader:
         """Return current upload statistics."""
         return self._summary
 
+    @property
+    def launch_id(self) -> str | None:
+        """Return the opened launch ID, or None if no launch was opened."""
+        return self._launch_id
+
+    @property
+    def project_id(self) -> str | None:
+        """Return the project UUID from the open-launch response, if available."""
+        return self._project_id
+
     def configure_logging(self) -> None:
         """Configure logging based on silent mode.
 
@@ -113,17 +125,45 @@ class Uploader:
             self._client = None
 
     def drain(self, timeout: float) -> None:
-        """Signal drain and wait for queue to empty or timeout to expire.
+        """Signal drain and wait until all consumed items are flushed/sent.
+
+        Waits for BOTH the queue to empty AND the in-memory batch to be flushed.
+        Waiting on queue emptiness alone is insufficient: the consumer moves a
+        result from the queue into ``self._batch`` (queue becomes empty) but only
+        flushes at 50 items or the 2s batch timeout. For short runs (e.g. a single
+        result enqueued by final_scan after the subprocess exits), that left the
+        result unsent — the ``watch results_sent=0`` bug. Once the queue is empty,
+        this forces a final batch flush so pending results are sent before return.
 
         Args:
-            timeout: Maximum seconds to wait for the queue to drain.
+            timeout: Maximum seconds to wait for the queue+batch to drain.
         """
         self._drain_event.set()
         deadline = time.monotonic() + timeout
-        while not self._queue.empty() and time.monotonic() < deadline:
-            time.sleep(0.1)
-        if not self._queue.empty():
-            logger.warning("Drain timeout expired with %d items remaining in queue", self._queue.qsize())
+
+        # Phase 1: wait for the queue to empty AND for the consumer to finish
+        # processing every dequeued item. Checking queue.empty() alone is racy:
+        # an item that has been dequeued but not yet appended to the batch is in
+        # neither the queue nor the batch. unfinished_tasks (decremented by the
+        # consumer's task_done()) closes that window.
+        while (
+            (not self._queue.empty() or self._queue.unfinished_tasks > 0)
+            and time.monotonic() < deadline
+        ):
+            time.sleep(0.05)
+
+        # Phase 2: the consumer is idle and everything is now in the batch (or
+        # already sent). Force out any partial batch that hasn't hit the 50-item
+        # or 2s trigger, so drain() honors its contract: everything consumed has
+        # been sent when it returns.
+        self._flush_batch()
+
+        if not self._queue.empty() or self._queue.unfinished_tasks > 0 or self._batch:
+            logger.warning(
+                "Drain timeout expired with %d queued and %d batched items remaining",
+                self._queue.qsize(),
+                len(self._batch),
+            )
 
     def open_launch(self) -> str | None:
         """Open a streaming launch via the API.
@@ -150,6 +190,7 @@ class Uploader:
                 if response.status_code == 201:
                     data = response.json()
                     self._launch_id = data["launchId"]
+                    self._project_id = data.get("projectId")
                     return self._launch_id
                 if response.status_code in RETRYABLE_STATUS_CODES and attempt < MAX_RETRIES:
                     time.sleep(exponential_backoff(attempt))
@@ -165,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:
@@ -411,13 +461,18 @@ class Uploader:
                 self._flush_batch()
 
     def _flush_batch(self) -> None:
-        """Send the current batch to the API."""
-        if not self._batch or not self._launch_id:
-            return
+        """Send the current batch to the API.
 
-        batch = self._batch[:]
-        self._batch = []
-        self._batch_start = 0.0
+        Thread-safe: the batch may be flushed by the consumer thread (on 50-item
+        or 2s-timeout triggers) or by drain() on the main thread. The lock ensures
+        the swap-and-clear is atomic so a batch is never sent twice or lost.
+        """
+        with self._batch_lock:
+            if not self._batch or not self._launch_id:
+                return
+            batch = self._batch[:]
+            self._batch = []
+            self._batch_start = 0.0
 
         success = self._send_batch(batch)
         if success:

{charisma_cli-0.1.2 → charisma_cli-0.1.5}/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.5/tests/test_launch_url.py

@@ -0,0 +1,37 @@
+"""Unit tests for charisma_cli.launch_url: URL construction + GitHub output emission."""
+
+from pathlib import Path
+
+from charisma_cli.launch_url import build_launch_url, emit_github_output
+
+
+class TestBuildLaunchUrl:
+    """build_launch_url mirrors the frontend /project/{id}/launches/{id} route."""
+
+    def test_basic_url(self) -> None:
+        url = build_launch_url("proj-uuid", "launch-uuid")
+        assert url == "https://charisma.aligntech.com/project/proj-uuid/launches/launch-uuid"
+
+
+class TestEmitGithubOutput:
+    """emit_github_output appends launch_url only when GITHUB_OUTPUT is set."""
+
+    def test_writes_when_github_output_set(self, tmp_path: Path, monkeypatch) -> None:
+        out = tmp_path / "gh_output"
+        out.write_text("")  # simulate existing GITHUB_OUTPUT file
+        monkeypatch.setenv("GITHUB_OUTPUT", str(out))
+
+        emit_github_output("https://charisma.aligntech.com/project/p/launches/l")
+
+        content = out.read_text()
+        assert "launch_url=https://charisma.aligntech.com/project/p/launches/l\n" in content
+
+    def test_noop_when_github_output_unset(self, monkeypatch) -> None:
+        monkeypatch.delenv("GITHUB_OUTPUT", raising=False)
+        # Should simply return without raising
+        emit_github_output("https://charisma.aligntech.com/project/p/launches/l")
+
+    def test_bad_path_does_not_raise(self, monkeypatch) -> None:
+        # Point at an unwritable/nonexistent directory — must be swallowed
+        monkeypatch.setenv("GITHUB_OUTPUT", "/nonexistent-dir-xyz/output")
+        emit_github_output("https://charisma.aligntech.com/project/p/launches/l")

{charisma_cli-0.1.2 → charisma_cli-0.1.5}/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.2 → charisma_cli-0.1.5}/tests/test_uploader.py

@@ -282,3 +282,52 @@ class TestUploaderSummary:
         assert summary.attachments_sent == 0
         assert summary.attachments_skipped == 0
         assert summary.containers_sent == 0
+
+
+class TestUploaderDrainFlushesBatch:
+    """Regression: drain() must flush the pending sub-batch, not just empty the queue.
+
+    Reproduces the `charismactl watch --> results_sent=0` bug: a short run enqueues
+    a single result after the subprocess exits (via final_scan). The consumer moves
+    it from the queue into the in-memory batch, which empties the queue immediately.
+    drain() only waits on queue emptiness, so it returns before the 2s batch-timeout
+    flush fires — leaving the result unsent. This mirrors the real CI failure where
+    `upload` (which flushes on stop) sent the result but `watch` reported 0.
+    """
+
+    @respx.mock
+    def test_drain_flushes_single_pending_result(self, tmp_path: Path) -> None:
+        """A single result enqueued just before drain must be SENT by drain().
+
+        Fails on the buggy implementation (result stuck in batch, results_sent=0);
+        passes once drain() forces a batch flush and waits for it.
+        """
+        config = _make_config()
+        queue: PriorityQueue = PriorityQueue()
+
+        results_route = respx.post(
+            "https://charisma.test/api/v1/launches/launch-1/results"
+        ).mock(return_value=httpx.Response(200, json={"accepted": 1}))
+
+        uploader = Uploader(config, queue)
+        uploader._launch_id = "launch-1"
+
+        uploader.start()
+
+        # Simulate final_scan enqueueing one result AFTER the subprocess exits,
+        # then draining — the real watch-mode sequence.
+        filepath = _make_result_file(tmp_path, "late-result.json")
+        queue.put(FileEvent(path=filepath, category=FileCategory.RESULT))
+
+        uploader.drain(timeout=5.0)
+
+        # Contract: after drain returns, the result must already be sent —
+        # not left sitting in the batch waiting on stop().
+        assert uploader.summary.results_sent == 1, (
+            "drain() returned but the pending result was not flushed/sent "
+            f"(results_sent={uploader.summary.results_sent}); "
+            "batch still held the result — this is the watch results_sent=0 bug"
+        )
+        assert results_route.called
+
+        uploader.stop()