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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

use clap::{Args, Subcommand};
use std::time::Duration;

use crate::args::{PositiveU64, PositiveUsize};

use super::super::defaults::{default_charts_path, default_tmp_path};
use super::super::parsers::{
    parse_bool_env, parse_duration_arg, parse_positive_u64, parse_positive_usize,
};

#[derive(Debug, Subcommand, Clone)]
pub enum Command {
    /// Quick baseline test with opinionated defaults
    Quick(PresetQuickArgs),
    /// Long-running steady test profile
    Soak(PresetSoakArgs),
    /// Short aggressive burst profile
    Spike(PresetSpikeArgs),
    /// Distributed controller preset (waits for N agents)
    Distributed(PresetDistributedArgs),
    /// Clean up temporary run data
    Cleanup(CleanupArgs),
    /// Compare two snapshot exports
    Compare(CompareArgs),
}

#[derive(Debug, Args, Clone)]
pub struct PresetQuickArgs {
    /// Target URL for the stress test
    #[arg(long, short)]
    pub url: String,

    /// Duration of test (seconds)
    #[arg(long = "duration", short = 't', default_value = "30", value_parser = parse_positive_u64)]
    pub target_duration: PositiveU64,

    /// Max number of concurrent request tasks
    #[arg(long = "max-tasks", default_value = "100", value_parser = parse_positive_usize)]
    pub max_tasks: PositiveUsize,

    /// Limit requests per second (optional)
    #[arg(long = "rate", short = 'q', value_parser = parse_positive_u64)]
    pub rate_limit: Option<PositiveU64>,
}

#[derive(Debug, Args, Clone)]
pub struct PresetSoakArgs {
    /// Target URL for the stress test
    #[arg(long, short)]
    pub url: String,

    /// Duration of test (seconds)
    #[arg(long = "duration", short = 't', default_value = "1800", value_parser = parse_positive_u64)]
    pub target_duration: PositiveU64,

    /// Max number of concurrent request tasks
    #[arg(long = "max-tasks", default_value = "300", value_parser = parse_positive_usize)]
    pub max_tasks: PositiveUsize,

    /// Limit requests per second (optional)
    #[arg(long = "rate", short = 'q', value_parser = parse_positive_u64)]
    pub rate_limit: Option<PositiveU64>,
}

#[derive(Debug, Args, Clone)]
pub struct PresetSpikeArgs {
    /// Target URL for the stress test
    #[arg(long, short)]
    pub url: String,

    /// Duration of test (seconds)
    #[arg(long = "duration", short = 't', default_value = "120", value_parser = parse_positive_u64)]
    pub target_duration: PositiveU64,

    /// Max number of concurrent request tasks
    #[arg(long = "max-tasks", default_value = "1000", value_parser = parse_positive_usize)]
    pub max_tasks: PositiveUsize,

    /// Tasks spawned per tick
    #[arg(long = "spawn-rate", default_value = "20", value_parser = parse_positive_usize)]
    pub spawn_rate_per_tick: PositiveUsize,

    /// Spawn interval in milliseconds
    #[arg(long = "spawn-interval", default_value = "100", value_parser = parse_positive_u64)]
    pub tick_interval: PositiveU64,
}

#[derive(Debug, Args, Clone)]
pub struct PresetDistributedArgs {
    /// Target URL for the stress test
    #[arg(long, short)]
    pub url: String,

    /// Expected number of agents before controller starts
    #[arg(long = "agents", default_value = "3", value_parser = parse_positive_usize)]
    pub agents: PositiveUsize,

    /// Duration of test (seconds)
    #[arg(long = "duration", short = 't', default_value = "300", value_parser = parse_positive_u64)]
    pub target_duration: PositiveU64,

    /// Controller listen address
    #[arg(long = "controller-listen", default_value = "0.0.0.0:9009")]
    pub controller_listen: String,

    /// Shared auth token for distributed mode (optional)
    #[arg(long = "auth-token")]
    pub auth_token: Option<String>,
}

#[derive(Debug, Args, Clone)]
pub struct CleanupArgs {
    /// Path to temporary run data (directory)
    #[arg(long = "tmp-path", default_value_t = default_tmp_path())]
    pub tmp_path: String,

    /// Also clean chart run directories
    #[arg(long = "with-charts")]
    pub with_charts: bool,

    /// Path to chart output data (directory)
    #[arg(long = "charts-path", default_value_t = default_charts_path())]
    pub charts_path: String,

    /// Only remove entries older than this duration (supports ms/s/m/h)
    #[arg(long = "older-than", value_parser = parse_duration_arg)]
    pub older_than: Option<Duration>,

    /// Show what would be removed without deleting anything
    #[arg(long = "dry-run")]
    pub dry_run: bool,

    /// Actually delete files
    #[arg(long = "force")]
    pub force: bool,
}

#[derive(Debug, Args, Clone)]
pub struct CompareArgs {
    /// Left snapshot file (csv/json/jsonl)
    pub left: String,

    /// Right snapshot file (csv/json/jsonl)
    pub right: String,

    /// Expected HTTP status code
    #[arg(long = "status", short = 's', default_value = "200")]
    pub expected_status_code: u16,

    /// Replay step size for compare mode (supports ms/s/m/h)
    #[arg(long = "replay-step", value_parser = parse_duration_arg)]
    pub replay_step: Option<Duration>,

    /// UI chart window length in milliseconds (default: 10000)
    #[arg(long = "ui-window-ms", default_value = "10000", value_parser = parse_positive_u64)]
    pub ui_window_ms: PositiveU64,

    /// Disable UI rendering
    #[arg(long = "no-tui", alias = "no-ui")]
    pub no_ui: bool,

    /// Disable color output
    #[arg(long = "no-color", env = "NO_COLOR", value_parser = parse_bool_env)]
    pub no_color: bool,

    /// Label for the left series
    #[arg(long = "left-label")]
    pub left_label: Option<String>,

    /// Label for the right series
    #[arg(long = "right-label")]
    pub right_label: Option<String>,
}