strobengine 0.5.0__tar.gz → 0.5.1__tar.gz

{strobengine-0.5.0 → strobengine-0.5.1}/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to `strobengine` will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.1] - 2026-09-01
+
+### Bug Fixes
+
+- *(websocket)* Use user-configured timeout for persistent session read
+- *(http)* Use user-configured method for CorruptedPayload chaos fault
+- *(report)* Handle Windows fs::rename target collision in writer
+- *(reporting)* Move rich import inside print_cli_comparison
+- *(websocket)* Warn on invalid WebSocket headers instead of silent drop
+
+### Refactoring
+
+- *(reporting)* Remove dead render_markdown_report function
+
+### Testing
+
+- *(reporting)* Add unit tests for baseline, html_report, and cli helpers
 ## [0.5.0] - 2026-08-30
 
 ### Documentation
@@ -51,6 +68,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - *(pyproject)* Simplify readme config and update documentation URL
 - *(scripts)* Run uv lock during release version bump
+- *(release)* Bump version to 0.5.0
 
 ### Styling
 

{strobengine-0.5.0 → strobengine-0.5.1}/Cargo.lock

@@ -1785,7 +1785,7 @@ checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
 [[package]]
 name = "strobengine"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "async-trait",
  "base64",

{strobengine-0.5.0 → strobengine-0.5.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strobengine"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2024"
 readme = "README.md"
 

{strobengine-0.5.0 → strobengine-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: strobengine
-Version: 0.5.0
+Version: 0.5.1
 Requires-Dist: rich>=13.0.0
 Requires-Dist: typer>=0.27.0
 Requires-Dist: jinja2>=3.1

{strobengine-0.5.0 → strobengine-0.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "strobengine"
-version = "0.5.0"
+version = "0.5.1"
 description = "A load testing framework with a Python UI and a bare-metal Rust engine core."
 readme = "README.md"
 license = "Apache-2.0"

{strobengine-0.5.0 → strobengine-0.5.1}/src/protocols/http.rs

@@ -97,7 +97,7 @@ impl ProtocolEngine for HttpEngine {
             Some(ChaosFault::CorruptedPayload) => {
                 tracing::trace!("chaos: corrupted payload injected");
                 self.client
-                    .post(target_url)
+                    .request(self.method.clone(), target_url)
                     .header(CHAOS_HEADER, "corrupted-payload")
                     .body(CORRUPTED_BODY)
             }

{strobengine-0.5.0 → strobengine-0.5.1}/src/protocols/websocket.rs

@@ -97,11 +97,16 @@ impl PersistentWsSession {
             .map_err(|e| EngineError::ConnectionFailed(e.to_string()))?;
 
         for (key, value) in &self.headers {
-            if let (Ok(name), Ok(val)) = (
+            match (
                 key.as_str().parse::<http::header::HeaderName>(),
                 value.as_str().parse(),
             ) {
-                request.headers_mut().insert(name, val);
+                (Ok(name), Ok(val)) => {
+                    request.headers_mut().insert(name, val);
+                }
+                _ => {
+                    tracing::warn!(key = %key, "invalid WebSocket header skipped");
+                }
             }
         }
 
@@ -136,7 +141,11 @@ impl PersistentWsSession {
         self.messages_sent += 1;
 
         // Read response with timeout
-        let timeout = Duration::from_secs(5);
+        let timeout = Duration::from_secs(if self.timeout_secs > 0 {
+            self.timeout_secs
+        } else {
+            5
+        });
         let read_result = tokio::time::timeout(timeout, async {
             let mut response_bytes = Vec::new();
             while let Some(Ok(msg)) = stream.next().await {
@@ -283,10 +292,13 @@ impl WebSocketEngine {
             .map_err(|e| EngineError::ConnectionFailed(e.to_string()))?;
 
         for (key, value) in headers {
-            if let (Ok(name), Ok(val)) =
-                (key.as_str().parse::<HeaderName>(), value.as_str().parse())
-            {
-                request.headers_mut().insert(name, val);
+            match (key.as_str().parse::<HeaderName>(), value.as_str().parse()) {
+                (Ok(name), Ok(val)) => {
+                    request.headers_mut().insert(name, val);
+                }
+                _ => {
+                    tracing::warn!(key = %key, "invalid WebSocket header skipped");
+                }
             }
         }
 

{strobengine-0.5.0 → strobengine-0.5.1}/src/report/writer.rs

@@ -57,6 +57,10 @@ pub fn save_report_json(
     // Atomic write: serialize → write tmp → rename to final
     let json_bytes = serde_json::to_vec_pretty(artifact)?;
     fs::write(&tmp_path, &json_bytes)?;
+
+    // Pre-emptively clear target for cross-platform compatibility (Windows)
+    let _ = fs::remove_file(&target_path);
+
     fs::rename(&tmp_path, &target_path)?;
 
     // Update latest.json pointer (also atomic)
@@ -74,6 +78,10 @@ fn update_latest_pointer(dir: &Path, filename: &str) -> Result<(), io::Error> {
     let json_bytes = serde_json::to_vec_pretty(&payload)?;
 
     fs::write(&latest_tmp, &json_bytes)?;
+
+    // Pre-emptively clear existing latest.json for cross-platform compatibility (Windows)
+    let _ = fs::remove_file(&latest_path);
+
     fs::rename(&latest_tmp, &latest_path)?;
 
     Ok(())
@@ -242,4 +250,27 @@ mod tests {
         );
         fs::remove_dir_all("./.strobengine").ok();
     }
+
+    #[test]
+    fn test_save_report_json_overwrites_existing_target() {
+        let dir = std::env::temp_dir().join("strobengine_test_overwrite");
+        let artifact = sample_artifact();
+
+        // First write — creates the file
+        let path1 = save_report_json(&artifact, Some(&dir), false).unwrap();
+        assert!(path1.exists());
+        let content1 = fs::read_to_string(&path1).unwrap();
+        assert!(content1.contains("metadata"));
+
+        // Second write — should overwrite (simulates same-second collision)
+        let path2 = save_report_json(&artifact, Some(&dir), false).unwrap();
+        assert!(path2.exists());
+        let content2 = fs::read_to_string(&path2).unwrap();
+        assert!(content2.contains("metadata"));
+
+        // Both paths should be the same (same filename)
+        assert_eq!(path1, path2);
+
+        fs::remove_dir_all(&dir).ok();
+    }
 }

{strobengine-0.5.0 → strobengine-0.5.1}/src/strobengine/reporting/baseline.py

@@ -6,9 +6,6 @@ import json
 import sys
 from pathlib import Path
 
-from rich.console import Console
-from rich.table import Table
-
 
 def load_baseline_artifact(
     report_dir: Path = Path(".strobengine/reports"),
@@ -87,6 +84,9 @@ def compute_comparison(current: dict, baseline: dict) -> dict:
 
 def print_cli_comparison(comparison: dict) -> None:
     """Print baseline comparison table to terminal using Rich."""
+    from rich.console import Console
+    from rich.table import Table
+
     console = Console()
     table = Table(title="Historical Comparison", show_lines=True, padding=(0, 1))
     table.add_column("Metric", style="bold cyan", no_wrap=True)

{strobengine-0.5.0 → strobengine-0.5.1}/src/strobengine/reporting/markdown_report.py

@@ -77,63 +77,6 @@ def generate_markdown_summary(artifact: dict) -> str:
     return "\n".join(lines)
 
 
-def render_markdown_report(summary, config, duration_secs: float) -> str:
-    """Render a Markdown report from TestSummary (full format with all details)."""
-    artifact = build_artifact_dict(summary, config)
-    meta = artifact["metadata"]
-    s = artifact["summary"]
-    lp = artifact["latency_percentiles"]
-
-    duration = duration_secs or meta.get("duration_secs", 0)
-    error_rate = (
-        (s["failed_requests"] / s["total_requests"] * 100)
-        if s["total_requests"] > 0
-        else 0.0
-    )
-    bytes_kb = s["bytes_transferred"] / 1024
-
-    lines = [
-        "# Load Test Results",
-        "",
-        "| Metric | Value |",
-        "|--------|-------|",
-        f"| Target URL | `{meta['target_url']}` |",
-        f"| Timestamp | {meta['timestamp']} |",
-        f"| Duration | {duration:.1f}s |",
-        f"| Concurrency | {meta['cli_options']['concurrency']} |",
-        f"| Method | {meta['cli_options']['method']} |",
-        f"| Total Requests | {s['total_requests']:,} |",
-        f"| Successful | {s['successful_requests']:,} |",
-        f"| Failed | {s['failed_requests']:,} |",
-        f"| Requests/sec | {s['rps']:.2f} |",
-        f"| P50 Latency | {lp['p50_us'] / 1000:.2f} ms |",
-        f"| P90 Latency | {lp['p90_us'] / 1000:.2f} ms |",
-        f"| P95 Latency | {lp['p95_us'] / 1000:.2f} ms |",
-        f"| P99 Latency | {lp['p99_us'] / 1000:.2f} ms |",
-        f"| Min Latency | {lp['min_us'] / 1000:.2f} ms |",
-        f"| Max Latency | {lp['max_us'] / 1000:.2f} ms |",
-        f"| Mean Latency | {lp['mean_us'] / 1000:.2f} ms |",
-        f"| Error Rate | {error_rate:.2f}% |",
-        f"| Bytes Transferred | {bytes_kb:.1f} KB |",
-        "",
-    ]
-
-    # Status code breakdown
-    if artifact["error_breakdown"]:
-        lines.append("## Status Codes")
-        lines.append("")
-        lines.append("| Code | Count |")
-        lines.append("|------|-------|")
-        for code, count in sorted(
-            artifact["error_breakdown"].items(),
-            key=lambda x: int(x[0]) if str(x[0]).isdigit() else 0,
-        ):
-            lines.append(f"| {code} | {count:,} |")
-        lines.append("")
-
-    return "\n".join(lines)
-
-
 def save_markdown_report(summary, config, filepath: str, duration_secs: float) -> str:
     """Render and write Markdown report to disk. Returns filepath."""
     filepath = str(Path(filepath).expanduser().resolve())

{strobengine-0.5.0 → strobengine-0.5.1}/tests/test_reporting.py

@@ -2,6 +2,9 @@
 
 from unittest.mock import Mock
 
+import pytest
+import typer
+
 
 def _make_summary(**kwargs):
     """Create a mock TestSummary with sensible defaults."""
@@ -250,3 +253,240 @@ class TestCSVReport:
         assert (tmp_path / "report.csv").exists()
         content = (tmp_path / "report.csv").read_text()
         assert "metric,value" in content
+
+
+class TestBaselineArtifact:
+    """Tests for load_baseline_artifact."""
+
+    def test_load_baseline_from_file(self, tmp_path):
+        from strobengine.reporting.baseline import load_baseline_artifact
+
+        artifact = {
+            "metadata": {
+                "timestamp": "2026-01-01T00:00:00Z",
+                "target_url": "http://test",
+            },
+            "summary": {"rps": 10.0, "total_requests": 100, "failed_requests": 0},
+            "latency_percentiles": {"p95_us": 5000.0},
+        }
+        filepath = tmp_path / "report.json"
+        filepath.write_text(__import__("json").dumps(artifact))
+
+        result = load_baseline_artifact(baseline_file=filepath)
+        assert result is not None
+        assert result["metadata"]["target_url"] == "http://test"
+
+    def test_load_baseline_file_not_found(self, tmp_path):
+        from strobengine.reporting.baseline import load_baseline_artifact
+
+        result = load_baseline_artifact(baseline_file=tmp_path / "nonexistent.json")
+        assert result is None
+
+    def test_load_baseline_corrupt_json(self, tmp_path):
+        from strobengine.reporting.baseline import load_baseline_artifact
+
+        filepath = tmp_path / "corrupt.json"
+        filepath.write_text("not valid json {{{")
+
+        result = load_baseline_artifact(baseline_file=filepath)
+        assert result is None
+
+    def test_load_baseline_latest_pointer(self, tmp_path):
+        from strobengine.reporting.baseline import load_baseline_artifact
+
+        artifact = {
+            "metadata": {
+                "timestamp": "2026-01-01T00:00:00Z",
+                "target_url": "http://test",
+            },
+            "summary": {"rps": 10.0, "total_requests": 100, "failed_requests": 0},
+            "latency_percentiles": {"p95_us": 5000.0},
+        }
+        report_file = tmp_path / "report_20260101_000000_test.json"
+        report_file.write_text(__import__("json").dumps(artifact))
+
+        latest = tmp_path / "latest.json"
+        latest.write_text(__import__("json").dumps({"latest_report": report_file.name}))
+
+        result = load_baseline_artifact(report_dir=tmp_path)
+        assert result is not None
+        assert result["summary"]["rps"] == 10.0
+
+    def test_load_baseline_latest_missing_target(self, tmp_path):
+        from strobengine.reporting.baseline import load_baseline_artifact
+
+        latest = tmp_path / "latest.json"
+        latest.write_text(
+            __import__("json").dumps({"latest_report": "nonexistent.json"})
+        )
+
+        result = load_baseline_artifact(report_dir=tmp_path)
+        assert result is None
+
+    def test_load_baseline_no_latest_file(self, tmp_path):
+        from strobengine.reporting.baseline import load_baseline_artifact
+
+        result = load_baseline_artifact(report_dir=tmp_path)
+        assert result is None
+
+
+class TestComputeComparison:
+    """Tests for compute_comparison."""
+
+    def _make_artifact(self, rps, total_requests, failed_requests, p95_us):
+        return {
+            "metadata": {
+                "timestamp": "2026-01-01T00:00:00Z",
+                "target_url": "http://test",
+            },
+            "summary": {
+                "total_requests": total_requests,
+                "failed_requests": failed_requests,
+                "rps": rps,
+            },
+            "latency_percentiles": {"p95_us": p95_us},
+        }
+
+    def test_compute_comparison_normal(self):
+        from strobengine.reporting.baseline import compute_comparison
+
+        current = self._make_artifact(
+            rps=40.0, total_requests=200, failed_requests=10, p95_us=25000.0
+        )
+        baseline = self._make_artifact(
+            rps=30.0, total_requests=150, failed_requests=5, p95_us=35000.0
+        )
+
+        result = compute_comparison(current, baseline)
+        assert result["rps_delta"] == 33.33
+        assert result["latency_p95_delta"] < 0  # improvement (lower latency)
+        assert result["error_rate_delta"] > 0  # regression (more errors)
+
+    def test_compute_comparison_improvement(self):
+        from strobengine.reporting.baseline import compute_comparison
+
+        current = self._make_artifact(
+            rps=50.0, total_requests=500, failed_requests=0, p95_us=20000.0
+        )
+        baseline = self._make_artifact(
+            rps=30.0, total_requests=300, failed_requests=30, p95_us=35000.0
+        )
+
+        result = compute_comparison(current, baseline)
+        assert result["rps_delta"] > 0  # RPS improved
+        assert result["latency_p95_delta"] < 0  # latency improved
+        assert result["error_rate_delta"] < 0  # errors improved
+
+    def test_compute_comparison_zero_baseline_rps(self):
+        from strobengine.reporting.baseline import compute_comparison
+
+        current = self._make_artifact(
+            rps=10.0, total_requests=100, failed_requests=0, p95_us=5000.0
+        )
+        baseline = self._make_artifact(
+            rps=0.0, total_requests=100, failed_requests=0, p95_us=5000.0
+        )
+
+        result = compute_comparison(current, baseline)
+        assert result["rps_delta"] == 100.0  # base=0, curr>0 -> 100%
+
+    def test_compute_comparison_zero_baseline_p95(self):
+        from strobengine.reporting.baseline import compute_comparison
+
+        current = self._make_artifact(
+            rps=10.0, total_requests=100, failed_requests=0, p95_us=10000.0
+        )
+        baseline = self._make_artifact(
+            rps=10.0, total_requests=100, failed_requests=0, p95_us=0.0
+        )
+
+        result = compute_comparison(current, baseline)
+        assert result["latency_p95_delta"] == 100.0  # base=0, curr>0 -> 100%
+
+
+class TestHTMLReport:
+    """Tests for render_html_report and save_html_report."""
+
+    def test_render_html_contains_charts(self):
+        from strobengine.reporting.html_report import render_html_report
+
+        html = render_html_report(_make_summary(), _make_config())
+        assert "<canvas" in html
+        assert "Chart" in html
+
+    def test_render_html_contains_metadata(self):
+        from strobengine.reporting.html_report import render_html_report
+
+        html = render_html_report(_make_summary(), _make_config())
+        assert "http://localhost:8080" in html
+        assert "10.0s" in html
+
+    def test_render_html_with_comparison(self):
+        from strobengine.reporting.html_report import render_html_report
+
+        comparison = {
+            "baseline_timestamp": "2026-01-01T00:00:00Z",
+            "rps_delta": 10.5,
+            "latency_p95_delta": -5.2,
+            "error_rate_delta": -1.0,
+            "baseline_rps": 30.0,
+            "baseline_p95_ms": 35.0,
+            "baseline_error_rate": 5.0,
+        }
+        html = render_html_report(
+            _make_summary(), _make_config(), comparison=comparison
+        )
+        assert "Historical Comparison" in html
+
+    def test_render_html_without_comparison(self):
+        from strobengine.reporting.html_report import render_html_report
+
+        html = render_html_report(_make_summary(), _make_config(), comparison=None)
+        assert "Historical Comparison" not in html
+
+    def test_render_html_status_grouping(self):
+        from strobengine.reporting.html_report import render_html_report
+
+        summary = _make_summary(total_errors=10, status_codes={200: 90, 404: 5, 500: 5})
+        html = render_html_report(summary, _make_config())
+        assert "2xx" in html
+        assert "4xx" in html
+        assert "5xx" in html
+
+    def test_save_html_report_file_output(self, tmp_path):
+        from strobengine.reporting.html_report import save_html_report
+
+        filepath = str(tmp_path / "report.html")
+        result = save_html_report(_make_summary(), _make_config(), filepath)
+        assert result == filepath
+        assert (tmp_path / "report.html").exists()
+        content = (tmp_path / "report.html").read_text()
+        assert "<html" in content
+
+
+class TestCLIHelpers:
+    """Tests for cli.py helper functions."""
+
+    def test_parse_headers_valid(self):
+        from strobengine.cli import _parse_headers
+
+        result = _parse_headers(["X-Custom: value"])
+        assert result == [("X-Custom", "value")]
+
+    def test_parse_headers_invalid(self):
+        from strobengine.cli import _parse_headers
+
+        with pytest.raises(typer.BadParameter):
+            _parse_headers(["NoColonHere"])
+
+    def test_validate_method_uppercase(self):
+        from strobengine.cli import _validate_method
+
+        assert _validate_method("get") == "GET"
+        assert _validate_method("post") == "POST"
+
+    def test_validate_method_invalid(self):
+        from strobengine.cli import _validate_method
+
+        with pytest.raises(typer.BadParameter):
+            _validate_method("INVALID")

{strobengine-0.5.0 → strobengine-0.5.1}/uv.lock

@@ -732,7 +732,7 @@ wheels = [
 
 [[package]]
 name = "strobengine"
-version = "0.5.0"
+version = "0.5.1"
 source = { editable = "." }
 dependencies = [
     { name = "jinja2" },