strobengine 0.5.0__tar.gz → 0.5.2__tar.gz

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

@@ -4,6 +4,45 @@ 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.2] - 2026-09-02
+
+### Bug Fixes
+
+- *(report)* Remove forced 2-decimal rounding of RPS in report schema
+- *(lib)* Log report persistence errors instead of silently discarding
+- *(reporter)* Replace hardcoded version string with dynamic resolution
+- *(reporting)* Validate baseline artifact structure in compute_comparison
+
+### Refactoring
+
+- *(lib)* Remove unnecessary clones on config.body, config.form, config.headers
+- *(websocket)* Remove unnecessary payload_bytes.clone() in publisher iteration
+- *(reporting)* Extract us_to_ms helper for latency conversion
+
+### Styling
+
+- *(tests)* Move duplicate inline imports to top of test_reporting.py
+## [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
+
+### Miscellaneous Tasks
+
+- *(release)* Bump version to 0.5.1
+
+### 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 +90,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.2}/Cargo.lock

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "strobengine"
-version = "0.5.0"
+version = "0.5.2"
 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.2}/src/lib.rs

@@ -72,11 +72,11 @@ fn parse_method(method_str: &str) -> PyResult<Method> {
     })
 }
 
-fn parse_body(body: Option<String>) -> Option<bytes::Bytes> {
-    body.map(bytes::Bytes::from)
+fn parse_body(body: Option<&str>) -> Option<bytes::Bytes> {
+    body.map(|b| bytes::Bytes::copy_from_slice(b.as_bytes()))
 }
 
-fn parse_form(form: Option<Vec<(String, String)>>) -> Option<bytes::Bytes> {
+fn parse_form(form: Option<&[(String, String)]>) -> Option<bytes::Bytes> {
     form.map(|pairs| {
         let encoded: String = pairs
             .iter()
@@ -87,7 +87,7 @@ fn parse_form(form: Option<Vec<(String, String)>>) -> Option<bytes::Bytes> {
     })
 }
 
-fn parse_headers(headers: Option<Vec<(String, String)>>) -> PyResult<HeaderMap> {
+fn parse_headers(headers: Option<&[(String, String)]>) -> PyResult<HeaderMap> {
     let mut header_map = HeaderMap::new();
 
     if let Some(h) = headers {
@@ -96,7 +96,7 @@ fn parse_headers(headers: Option<Vec<(String, String)>>) -> PyResult<HeaderMap>
                 pyo3::exceptions::PyValueError::new_err(format!("Invalid header name '{k}': {e}"))
             })?;
 
-            let val = HeaderValue::from_str(&v).map_err(|e| {
+            let val = HeaderValue::from_str(v).map_err(|e| {
                 pyo3::exceptions::PyValueError::new_err(format!(
                     "Invalid header value for '{k}': {e}"
                 ))
@@ -479,9 +479,9 @@ fn run_load_test(py: Python<'_>, config: TestConfig) -> PyResult<metrics::TestSu
                 protocols::detect_protocol(&url, &config, chaos)
             } else {
                 let method = parse_method(&config.method)?;
-                let body = parse_body(config.body.clone());
-                let form = parse_form(config.form.clone());
-                let header_map = parse_headers(config.headers.clone())?;
+                let body = parse_body(config.body.as_deref());
+                let form = parse_form(config.form.as_deref());
+                let header_map = parse_headers(config.headers.as_deref())?;
 
                 // Resolve payload and auto-inject Content-Type
                 let is_form = form.is_some();
@@ -533,11 +533,13 @@ fn run_load_test(py: Python<'_>, config: TestConfig) -> PyResult<metrics::TestSu
         if !config.no_save {
             let artifact =
                 report::schema::ReportArtifact::from_summary_and_config(&summary, &config);
-            let _ = report::writer::save_report_json(
+            if let Err(e) = report::writer::save_report_json(
                 &artifact,
                 config.output_dir.as_deref().map(std::path::Path::new),
                 false,
-            );
+            ) {
+                tracing::warn!(error = %e, "failed to save report artifact");
+            }
         }
 
         Ok(summary)
@@ -575,9 +577,9 @@ fn run_load_profiles(
         let chaos_engine = ChaosEngine::new(chaos, chaos_rate);
 
         let method = parse_method(method)?;
-        let raw_body = parse_body(body);
-        let raw_form = parse_form(form);
-        let mut header_map = parse_headers(headers.clone())?;
+        let raw_body = parse_body(body.as_deref());
+        let raw_form = parse_form(form.as_deref());
+        let mut header_map = parse_headers(headers.as_deref())?;
 
         // Resolve payload and auto-inject Content-Type
         let is_form = raw_form.is_some();

{strobengine-0.5.0 → strobengine-0.5.2}/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.2}/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");
+                }
             }
         }
 
@@ -343,8 +355,9 @@ impl WebSocketEngine {
             Some(w) => w,
             None => return RequestMetric::error(req_start.elapsed().as_micros()),
         };
+        let payload_len = payload_bytes.len() as u64;
         let send_result = write
-            .send(Message::Binary(Bytes::from(payload_bytes.clone())))
+            .send(Message::Binary(Bytes::from(payload_bytes)))
             .await;
 
         let latency_micros = req_start.elapsed().as_micros();
@@ -355,7 +368,7 @@ impl WebSocketEngine {
                 RequestMetric {
                     latency_micros,
                     status_code: 200,
-                    bytes_received: payload_bytes.len() as u64,
+                    bytes_received: payload_len,
                     is_reconnect: false,
                     connection_latency_us: None,
                     timestamp_sent_ns: Some(wallclock_ns()),

{strobengine-0.5.0 → strobengine-0.5.2}/src/report/schema.rs

@@ -115,7 +115,7 @@ impl ReportArtifact {
                 total_requests: summary.total_requests as u64,
                 successful_requests: successful,
                 failed_requests: summary.total_errors as u64,
-                rps: (rps * 100.0).round() / 100.0,
+                rps,
                 bytes_transferred: summary.total_bytes_received,
             },
             latency_percentiles: LatencyPercentiles {

{strobengine-0.5.0 → strobengine-0.5.2}/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.2}/src/strobengine/reporter.py

@@ -230,11 +230,17 @@ def _slugify_url(url: str) -> str:
 def _get_system_info() -> dict:
     """Collect basic system information for report metadata."""
     import socket
+    from importlib.metadata import PackageNotFoundError, version
+
+    try:
+        pkg_version = version("strobengine")
+    except PackageNotFoundError:
+        pkg_version = "0.0.0-dev"
 
     return {
         "hostname": socket.gethostname(),
         "platform": sys.platform,
-        "version": "0.5.0",
+        "version": pkg_version,
     }
 
 

strobengine-0.5.2/src/strobengine/reporting/__init__.py

@@ -0,0 +1,8 @@
+"""Shared utilities for reporting modules."""
+
+
+def us_to_ms(us: float | None) -> float:
+    """Convert microseconds to milliseconds, rounded to 2 decimal places."""
+    if us is None:
+        return 0.0
+    return round(us / 1000, 2)

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

@@ -6,8 +6,7 @@ import json
 import sys
 from pathlib import Path
 
-from rich.console import Console
-from rich.table import Table
+from strobengine.reporting import us_to_ms
 
 
 def load_baseline_artifact(
@@ -47,6 +46,8 @@ def compute_comparison(current: dict, baseline: dict) -> dict:
 
     Returns a dict with baseline metadata, current values, and percentage/point
     deltas for RPS, P95 latency, and error rate.
+
+    Raises ValueError if either artifact is missing required keys.
     """
 
     def pct_delta(curr_val: float, base_val: float) -> float:
@@ -54,6 +55,24 @@ def compute_comparison(current: dict, baseline: dict) -> dict:
             return 0.0 if curr_val == 0 else 100.0
         return round(((curr_val - base_val) / base_val) * 100, 2)
 
+    # Validate required structure
+    for label, artifact in [("current", current), ("baseline", baseline)]:
+        for key in ["summary", "latency_percentiles", "metadata"]:
+            if key not in artifact:
+                raise ValueError(
+                    f"Invalid {label} artifact: missing required key '{key}'"
+                )
+        for subkey in ["rps", "total_requests", "failed_requests"]:
+            if subkey not in artifact["summary"]:
+                raise ValueError(
+                    f"Invalid {label} artifact: missing 'summary.{subkey}'"
+                )
+        for subkey in ["p95_us"]:
+            if subkey not in artifact["latency_percentiles"]:
+                raise ValueError(
+                    f"Invalid {label} artifact: missing 'latency_percentiles.{subkey}'"
+                )
+
     curr_summary = current["summary"]
     base_summary = baseline["summary"]
     curr_lp = current["latency_percentiles"]
@@ -77,16 +96,19 @@ def compute_comparison(current: dict, baseline: dict) -> dict:
         "rps_delta": pct_delta(curr_summary["rps"], base_summary["rps"]),
         "error_rate_delta": round(curr_error_rate - base_error_rate, 2),
         "baseline_rps": base_summary["rps"],
-        "baseline_p95_ms": round(base_lp["p95_us"] / 1000, 2),
+        "baseline_p95_ms": us_to_ms(base_lp["p95_us"]),
         "baseline_error_rate": round(base_error_rate, 2),
         "current_rps": curr_summary["rps"],
-        "current_p95_ms": round(curr_lp["p95_us"] / 1000, 2),
+        "current_p95_ms": us_to_ms(curr_lp["p95_us"]),
         "current_error_rate": round(curr_error_rate, 2),
     }
 
 
 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.2}/src/strobengine/reporting/html_report.py

@@ -192,12 +192,14 @@ def render_html_report(summary, config, comparison=None) -> str:
     artifact = build_artifact_dict(summary, config)
 
     # Convert us -> ms for chart display
+    from strobengine.reporting import us_to_ms
+
     lp = artifact["latency_percentiles"]
     latency_ms = {
-        "p50": round((lp.get("p50_us") or 0) / 1000, 2),
-        "p90": round((lp.get("p90_us") or 0) / 1000, 2),
-        "p95": round((lp.get("p95_us") or 0) / 1000, 2),
-        "p99": round((lp.get("p99_us") or 0) / 1000, 2),
+        "p50": us_to_ms(lp.get("p50_us")),
+        "p90": us_to_ms(lp.get("p90_us")),
+        "p95": us_to_ms(lp.get("p95_us")),
+        "p99": us_to_ms(lp.get("p99_us")),
     }
 
     # Group status codes by class

{strobengine-0.5.0 → strobengine-0.5.2}/src/strobengine/reporting/junit_report.py

@@ -24,7 +24,9 @@ def generate_junit_report(artifact: dict) -> str:
     failed = s["failed_requests"]
     total = s["total_requests"]
     error_rate = (failed / total * 100) if total > 0 else 0.0
-    p95_ms = lp["p95_us"] / 1000
+    from strobengine.reporting import us_to_ms
+
+    p95_ms = us_to_ms(lp["p95_us"])
 
     testsuites = Element("testsuites")
     testsuite = SubElement(
@@ -48,9 +50,9 @@ def generate_junit_report(artifact: dict) -> str:
     so1 = SubElement(tc1, "system-out")
     so1.text = (
         f"RPS: {s['rps']:.2f}, "
-        f"P50: {lp['p50_us'] / 1000:.2f}ms, "
-        f"P95: {p95_ms:.2f}ms, "
-        f"P99: {lp['p99_us'] / 1000:.2f}ms, "
+        f"P50: {us_to_ms(lp['p50_us'])}ms, "
+        f"P95: {p95_ms}ms, "
+        f"P99: {us_to_ms(lp['p99_us'])}ms, "
         f"Errors: {error_rate:.2f}%, "
         f"Total: {total:,}"
     )

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

@@ -5,6 +5,7 @@ from __future__ import annotations
 from pathlib import Path
 
 from strobengine.reporter import build_artifact_dict
+from strobengine.reporting import us_to_ms
 
 
 def generate_markdown_summary(artifact: dict) -> str:
@@ -43,10 +44,10 @@ def generate_markdown_summary(artifact: dict) -> str:
         f"| Successful | {s['successful_requests']:,} |",
         f"| Failed | {failed:,} |",
         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"| P50 Latency | {us_to_ms(lp['p50_us'])} ms |",
+        f"| P90 Latency | {us_to_ms(lp['p90_us'])} ms |",
+        f"| P95 Latency | {us_to_ms(lp['p95_us'])} ms |",
+        f"| P99 Latency | {us_to_ms(lp['p99_us'])} ms |",
         f"| Error Rate | {error_rate:.2f}% |",
         "",
     ]
@@ -77,63 +78,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())