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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProtocolKind {
    Http,
    GrpcUnary,
    GrpcStreaming,
    Websocket,
    Tcp,
    Udp,
    Quic,
    Mqtt,
    Enet,
    Kcp,
    Raknet,
}

impl ProtocolKind {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            ProtocolKind::Http => "http",
            ProtocolKind::GrpcUnary => "grpc-unary",
            ProtocolKind::GrpcStreaming => "grpc-streaming",
            ProtocolKind::Websocket => "websocket",
            ProtocolKind::Tcp => "tcp",
            ProtocolKind::Udp => "udp",
            ProtocolKind::Quic => "quic",
            ProtocolKind::Mqtt => "mqtt",
            ProtocolKind::Enet => "enet",
            ProtocolKind::Kcp => "kcp",
            ProtocolKind::Raknet => "raknet",
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LoadMode {
    Arrival,
    Step,
    Ramp,
    Jitter,
    Burst,
    Soak,
}

impl LoadMode {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            LoadMode::Arrival => "arrival",
            LoadMode::Step => "step",
            LoadMode::Ramp => "ramp",
            LoadMode::Jitter => "jitter",
            LoadMode::Burst => "burst",
            LoadMode::Soak => "soak",
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Scenario {
    pub base_url: Option<String>,
    pub vars_count: usize,
    pub step_count: usize,
}

#[derive(Debug, Clone)]
pub struct RunConfig {
    pub protocol: ProtocolKind,
    pub load_mode: LoadMode,
    pub target_url: Option<String>,
    pub scenario: Option<Scenario>,
}

impl RunConfig {
    #[must_use]
    pub fn scenario_step_count(&self) -> usize {
        self.scenario
            .as_ref()
            .map(|scenario| scenario.step_count)
            .unwrap_or(0)
    }

    #[must_use]
    pub fn scenario_vars_count(&self) -> usize {
        self.scenario
            .as_ref()
            .map(|scenario| scenario.vars_count)
            .unwrap_or(0)
    }

    #[must_use]
    pub fn scenario_base_url(&self) -> Option<&str> {
        self.scenario
            .as_ref()
            .and_then(|scenario| scenario.base_url.as_deref())
    }
}