strest 0.1.10

Blazing-fast async HTTP load tester in Rust - lock-free design, real-time stats, distributed runs, and optional chart exports for high-load API testing.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use std::collections::{HashMap, VecDeque};

use tokio::sync::watch;

use crate::error::{AppError, AppResult};
use crate::ui::model::UiData;

use super::{AgentSnapshot, WireSummary, base_args, build_hist, update_ui};

#[test]
fn update_ui_emits_aggregated_stats() -> AppResult<()> {
    let args = base_args()?;
    let (ui_tx, ui_rx) = watch::channel(UiData::default());

    let summary = WireSummary {
        duration_ms: 1000,
        total_requests: 10,
        successful_requests: 9,
        error_requests: 1,
        timeout_requests: 0,
        transport_errors: 0,
        non_expected_status: 1,
        success_min_latency_ms: 10,
        success_max_latency_ms: 50,
        success_latency_sum_ms: 900,
        min_latency_ms: 10,
        max_latency_ms: 50,
        latency_sum_ms: 1000,
    };
    let hist = build_hist(&[10, 20, 30])?;
    let success_hist = build_hist(&[10, 20, 30])?;

    let mut agent_states = HashMap::new();
    agent_states.insert(
        "a".to_owned(),
        AgentSnapshot {
            summary,
            histogram: hist,
            success_histogram: success_hist,
        },
    );

    let mut latency_window = VecDeque::new();
    let mut rps_window = VecDeque::new();
    update_ui(
        &ui_tx,
        &args,
        &agent_states,
        &mut latency_window,
        &mut rps_window,
    );

    let snapshot = ui_rx.borrow().clone();
    if snapshot.current_requests != 10 {
        return Err(AppError::distributed(format!(
            "Unexpected current_requests: {}",
            snapshot.current_requests
        )));
    }
    if snapshot.successful_requests != 9 {
        return Err(AppError::distributed(format!(
            "Unexpected successful_requests: {}",
            snapshot.successful_requests
        )));
    }
    if snapshot.p50 == 0 {
        return Err(AppError::distributed("Expected non-zero p50 latency"));
    }
    if snapshot.rps == 0 {
        return Err(AppError::distributed("Expected non-zero rps"));
    }
    Ok(())
}