httpress 0.6.0

A fast HTTP benchmarking tool built in Rust
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

#![allow(dead_code)]

use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::time::Duration;

use axum::{
    Router,
    extract::{Path, State},
    http::StatusCode,
    routing::get,
};
use tokio::net::TcpListener;
use tokio::task::JoinHandle;

/// A test HTTP server for integration tests.
pub struct TestServer {
    pub base_url: String,
    handle: JoinHandle<()>,
}

impl TestServer {
    /// Start a new test server on a random available port.
    pub async fn start() -> Self {
        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let port = listener.local_addr().unwrap().port();
        let base_url = format!("http://127.0.0.1:{}", port);

        let app = Router::new()
            .route("/ok", get(ok_handler))
            .route("/delay/{ms}", get(delay_handler))
            .route("/status/{code}", get(status_handler))
            .route("/body/{size}", get(body_handler));

        let handle = tokio::spawn(async move {
            axum::serve(listener, app).await.unwrap();
        });

        // Give the server a moment to start
        tokio::time::sleep(Duration::from_millis(10)).await;

        Self { base_url, handle }
    }

    /// Start a test server with a flaky endpoint that fails N times before succeeding.
    pub async fn start_flaky(fail_count: usize) -> Self {
        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let port = listener.local_addr().unwrap().port();
        let base_url = format!("http://127.0.0.1:{}", port);

        let counter = Arc::new(AtomicUsize::new(0));

        let app = Router::new()
            .route("/ok", get(ok_handler))
            .route("/delay/{ms}", get(delay_handler))
            .route("/status/{code}", get(status_handler))
            .route("/body/{size}", get(body_handler))
            .route("/flaky", get(flaky_handler))
            .with_state(FlakyState {
                counter,
                fail_count,
            });

        let handle = tokio::spawn(async move {
            axum::serve(listener, app).await.unwrap();
        });

        tokio::time::sleep(Duration::from_millis(10)).await;

        Self { base_url, handle }
    }

    /// Start a test server with rotating status codes.
    pub async fn start_rotating(codes: Vec<u16>) -> Self {
        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let port = listener.local_addr().unwrap().port();
        let base_url = format!("http://127.0.0.1:{}", port);

        let counter = Arc::new(AtomicUsize::new(0));

        let app = Router::new()
            .route("/ok", get(ok_handler))
            .route("/delay/{ms}", get(delay_handler))
            .route("/status/{code}", get(status_handler))
            .route("/body/{size}", get(body_handler))
            .route("/rotating", get(rotating_handler))
            .with_state(RotatingState { counter, codes });

        let handle = tokio::spawn(async move {
            axum::serve(listener, app).await.unwrap();
        });

        tokio::time::sleep(Duration::from_millis(10)).await;

        Self { base_url, handle }
    }
}

impl Drop for TestServer {
    fn drop(&mut self) {
        self.handle.abort();
    }
}

// Handlers

async fn ok_handler() -> &'static str {
    "OK"
}

async fn delay_handler(Path(ms): Path<u64>) -> &'static str {
    tokio::time::sleep(Duration::from_millis(ms)).await;
    "OK"
}

async fn status_handler(Path(code): Path<u16>) -> StatusCode {
    StatusCode::from_u16(code).unwrap_or(StatusCode::BAD_REQUEST)
}

async fn body_handler(Path(size): Path<usize>) -> String {
    "x".repeat(size)
}

// Flaky server state
#[derive(Clone)]
struct FlakyState {
    counter: Arc<AtomicUsize>,
    fail_count: usize,
}

async fn flaky_handler(State(state): State<FlakyState>) -> StatusCode {
    let count = state.counter.fetch_add(1, Ordering::SeqCst);
    if count < state.fail_count {
        StatusCode::INTERNAL_SERVER_ERROR
    } else {
        StatusCode::OK
    }
}

// Rotating status code state
#[derive(Clone)]
struct RotatingState {
    counter: Arc<AtomicUsize>,
    codes: Vec<u16>,
}

async fn rotating_handler(State(state): State<RotatingState>) -> StatusCode {
    let count = state.counter.fetch_add(1, Ordering::SeqCst);
    let code = state.codes[count % state.codes.len()];
    StatusCode::from_u16(code).unwrap_or(StatusCode::BAD_REQUEST)
}