strobengine 0.5.1__tar.gz → 0.5.2__tar.gz

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

@@ -4,6 +4,24 @@ 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
@@ -14,6 +32,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - *(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

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "strobengine"
-version = "0.5.1"
+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.1 → 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.1 → strobengine-0.5.2}/src/protocols/websocket.rs

@@ -355,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();
@@ -367,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.1 → 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.1 → 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.1 → strobengine-0.5.2}/src/strobengine/reporting/baseline.py

@@ -6,6 +6,8 @@ import json
 import sys
 from pathlib import Path
 
+from strobengine.reporting import us_to_ms
+
 
 def load_baseline_artifact(
     report_dir: Path = Path(".strobengine/reports"),
@@ -44,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:
@@ -51,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"]
@@ -74,10 +96,10 @@ 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),
     }
 

{strobengine-0.5.1 → 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.1 → 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.1 → 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}% |",
         "",
     ]

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

@@ -5,6 +5,17 @@ from unittest.mock import Mock
 import pytest
 import typer
 
+from strobengine.cli import _parse_headers, _validate_method
+from strobengine.reporter import build_artifact_dict
+from strobengine.reporting.baseline import compute_comparison, load_baseline_artifact
+from strobengine.reporting.csv_report import generate_csv_report, save_csv_report
+from strobengine.reporting.html_report import render_html_report, save_html_report
+from strobengine.reporting.junit_report import generate_junit_report
+from strobengine.reporting.markdown_report import (
+    generate_markdown_summary,
+    save_markdown_report,
+)
+
 
 def _make_summary(**kwargs):
     """Create a mock TestSummary with sensible defaults."""
@@ -57,18 +68,12 @@ class TestMarkdownSummary:
     """Tests for generate_markdown_summary."""
 
     def test_pass_badge_when_no_errors(self):
-        from strobengine.reporter import build_artifact_dict
-        from strobengine.reporting.markdown_report import generate_markdown_summary
-
         artifact = build_artifact_dict(_make_summary(), _make_config())
         md = generate_markdown_summary(artifact)
         assert "PASS" in md
         assert "brightgreen" in md
 
     def test_fail_badge_when_errors(self):
-        from strobengine.reporter import build_artifact_dict
-        from strobengine.reporting.markdown_report import generate_markdown_summary
-
         artifact = build_artifact_dict(
             _make_summary(total_errors=5, status_codes={200: 95, 500: 5}),
             _make_config(),
@@ -78,9 +83,6 @@ class TestMarkdownSummary:
         assert "red" in md
 
     def test_has_metrics_table(self):
-        from strobengine.reporter import build_artifact_dict
-        from strobengine.reporting.markdown_report import generate_markdown_summary
-
         artifact = build_artifact_dict(_make_summary(), _make_config())
         md = generate_markdown_summary(artifact)
         assert "P95 Latency" in md
@@ -88,9 +90,6 @@ class TestMarkdownSummary:
         assert "Total Requests" in md
 
     def test_error_details_collapsible(self):
-        from strobengine.reporter import build_artifact_dict
-        from strobengine.reporting.markdown_report import generate_markdown_summary
-
         artifact = build_artifact_dict(
             _make_summary(total_errors=5, status_codes={200: 95, 500: 5}),
             _make_config(),
@@ -101,17 +100,11 @@ class TestMarkdownSummary:
         assert "</details>" in md
 
     def test_no_errors_no_details_section(self):
-        from strobengine.reporter import build_artifact_dict
-        from strobengine.reporting.markdown_report import generate_markdown_summary
-
         artifact = build_artifact_dict(_make_summary(), _make_config())
         md = generate_markdown_summary(artifact)
         assert "<details>" not in md
 
     def test_zero_requests_no_crash(self):
-        from strobengine.reporter import build_artifact_dict
-        from strobengine.reporting.markdown_report import generate_markdown_summary
-
         artifact = build_artifact_dict(
             _make_summary(total_requests=0, total_errors=0, status_codes={}),
             _make_config(),
@@ -125,8 +118,6 @@ class TestMarkdownReportFile:
     """Tests for save_markdown_report file output."""
 
     def test_save_markdown_report(self, tmp_path):
-        from strobengine.reporting.markdown_report import save_markdown_report
-
         filepath = str(tmp_path / "report.md")
         result = save_markdown_report(_make_summary(), _make_config(), filepath, 10.0)
         assert result == filepath
@@ -135,8 +126,6 @@ class TestMarkdownReportFile:
         assert "PASS" in content
 
     def test_save_markdown_report_expands_user(self, tmp_path, monkeypatch):
-        from strobengine.reporting.markdown_report import save_markdown_report
-
         monkeypatch.setenv("HOME", str(tmp_path))
         result = save_markdown_report(
             _make_summary(), _make_config(), "~/test_report.md", 10.0
@@ -148,9 +137,6 @@ class TestJUnitReport:
     """Tests for generate_junit_report."""
 
     def test_generate_junit_xml_structure(self):
-        from strobengine.reporter import build_artifact_dict
-        from strobengine.reporting.junit_report import generate_junit_report
-
         artifact = build_artifact_dict(_make_summary(), _make_config())
         xml = generate_junit_report(artifact)
         assert "<testsuites>" in xml
@@ -158,9 +144,6 @@ class TestJUnitReport:
         assert "<testcase" in xml
 
     def test_generate_junit_failure_when_errors(self):
-        from strobengine.reporter import build_artifact_dict
-        from strobengine.reporting.junit_report import generate_junit_report
-
         # 5 errors out of 100 = 5% > 1% threshold
         # Triggers failures on both load_test and error_rate_threshold testcases
         artifact = build_artifact_dict(
@@ -172,18 +155,12 @@ class TestJUnitReport:
         assert "performance_regression" in xml
 
     def test_generate_junit_no_failure_when_clean(self):
-        from strobengine.reporter import build_artifact_dict
-        from strobengine.reporting.junit_report import generate_junit_report
-
         artifact = build_artifact_dict(_make_summary(), _make_config())
         xml = generate_junit_report(artifact)
         assert 'failures="0"' in xml
         assert "<failure" not in xml
 
     def test_generate_junit_error_rate_threshold(self):
-        from strobengine.reporter import build_artifact_dict
-        from strobengine.reporting.junit_report import generate_junit_report
-
         # 5 errors out of 100 = 5% > 1% threshold
         artifact = build_artifact_dict(
             _make_summary(total_errors=5, status_codes={200: 95, 500: 5}),
@@ -194,9 +171,6 @@ class TestJUnitReport:
         assert "threshold_breach" in xml
 
     def test_generate_junit_p95_threshold(self):
-        from strobengine.reporter import build_artifact_dict
-        from strobengine.reporting.junit_report import generate_junit_report
-
         # P95 = 150ms > 100ms threshold
         artifact = build_artifact_dict(
             _make_summary(p95_latency_ms=150.0),
@@ -211,18 +185,12 @@ class TestCSVReport:
     """Tests for generate_csv_report."""
 
     def test_generate_csv_has_header(self):
-        from strobengine.reporter import build_artifact_dict
-        from strobengine.reporting.csv_report import generate_csv_report
-
         artifact = build_artifact_dict(_make_summary(), _make_config())
         csv_output = generate_csv_report(artifact)
         first_line = csv_output.strip().split("\n")[0]
         assert first_line == "metric,value"
 
     def test_generate_csv_has_all_fields(self):
-        from strobengine.reporter import build_artifact_dict
-        from strobengine.reporting.csv_report import generate_csv_report
-
         artifact = build_artifact_dict(_make_summary(), _make_config())
         csv_output = generate_csv_report(artifact)
         assert "timestamp" in csv_output
@@ -234,9 +202,6 @@ class TestCSVReport:
         assert "p99_us" in csv_output
 
     def test_generate_csv_microsecond_latencies(self):
-        from strobengine.reporter import build_artifact_dict
-        from strobengine.reporting.csv_report import generate_csv_report
-
         artifact = build_artifact_dict(_make_summary(), _make_config())
         csv_output = generate_csv_report(artifact)
         # p50 = 1.0 ms = 1000 us
@@ -245,8 +210,6 @@ class TestCSVReport:
         assert "p95_us,3000" in csv_output
 
     def test_generate_csv_file_output(self, tmp_path):
-        from strobengine.reporting.csv_report import save_csv_report
-
         filepath = str(tmp_path / "report.csv")
         result = save_csv_report(_make_summary(), _make_config(), filepath, 10.0)
         assert result == filepath
@@ -259,7 +222,7 @@ class TestBaselineArtifact:
     """Tests for load_baseline_artifact."""
 
     def test_load_baseline_from_file(self, tmp_path):
-        from strobengine.reporting.baseline import load_baseline_artifact
+        import json
 
         artifact = {
             "metadata": {
@@ -270,21 +233,17 @@ class TestBaselineArtifact:
             "latency_percentiles": {"p95_us": 5000.0},
         }
         filepath = tmp_path / "report.json"
-        filepath.write_text(__import__("json").dumps(artifact))
+        filepath.write_text(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 {{{")
 
@@ -292,7 +251,7 @@ class TestBaselineArtifact:
         assert result is None
 
     def test_load_baseline_latest_pointer(self, tmp_path):
-        from strobengine.reporting.baseline import load_baseline_artifact
+        import json
 
         artifact = {
             "metadata": {
@@ -303,29 +262,25 @@ class TestBaselineArtifact:
             "latency_percentiles": {"p95_us": 5000.0},
         }
         report_file = tmp_path / "report_20260101_000000_test.json"
-        report_file.write_text(__import__("json").dumps(artifact))
+        report_file.write_text(json.dumps(artifact))
 
         latest = tmp_path / "latest.json"
-        latest.write_text(__import__("json").dumps({"latest_report": report_file.name}))
+        latest.write_text(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
+        import json
 
         latest = tmp_path / "latest.json"
-        latest.write_text(
-            __import__("json").dumps({"latest_report": "nonexistent.json"})
-        )
+        latest.write_text(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
 
@@ -348,8 +303,6 @@ class TestComputeComparison:
         }
 
     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
         )
@@ -363,8 +316,6 @@ class TestComputeComparison:
         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
         )
@@ -378,8 +329,6 @@ class TestComputeComparison:
         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
         )
@@ -391,8 +340,6 @@ class TestComputeComparison:
         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
         )
@@ -408,22 +355,16 @@ 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,
@@ -439,14 +380,10 @@ class TestHTMLReport:
         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
@@ -454,8 +391,6 @@ class TestHTMLReport:
         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
@@ -468,25 +403,17 @@ 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.1 → strobengine-0.5.2}/uv.lock

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