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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: charisma-cli
-Version: 0.1.4
+Version: 0.1.5
 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.5}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "charisma-cli"
-version = "0.1.4"
+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.4 → charisma_cli-0.1.5}/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.
 
@@ -184,7 +197,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 +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.4 → 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.4 → charisma_cli-0.1.5}/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.4 → 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.4 → 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") == {}