whyhttp 0.1.0

HTTP mock server for use in tests. Starts a real server, expectations configured via fluent builder API, verified automatically on drop.
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

use std::{
    net::{SocketAddr, TcpListener},
    sync::mpsc::{Sender, TryRecvError, channel},
    thread,
    time::Duration,
};

use tiny_http::Server;

use crate::{io::Request, print::logln, worker::SharedWorker};

/// Starts an HTTP server backed by the shared worker.
///
/// Returns a shutdown sender and the bound socket address.
/// The server runs in a dedicated thread and polls both incoming requests
/// and the shutdown channel.
pub fn run_server(shared_worker: SharedWorker) -> (Sender<()>, SocketAddr) {
    let (shutdown_tx, shutdown_rx) = channel();
    let listener = TcpListener::bind(("0.0.0.0", 0)).unwrap();
    let addr = listener.local_addr().unwrap();
    let port = addr.port();
    thread::spawn(move || {
        let server = Server::from_listener(listener, None).unwrap();
        logln!(0, "LOG", "Server is listening on port {port}");
        loop {
            match shutdown_rx.try_recv() {
                Ok(()) | Err(TryRecvError::Disconnected) => break,
                Err(TryRecvError::Empty) => {}
            }

            match server.try_recv() {
                Ok(Some(req)) => handle(shared_worker.clone(), req),
                Ok(None) => thread::sleep(Duration::from_millis(5)),
                Err(_) => break,
            }
        }
        logln!(0, "LOG", "Server on port {port} has been stopped");
    });

    (shutdown_tx, addr)
}

fn handle(shared_worker: SharedWorker, mut incoming: tiny_http::Request) {
    let request = Request::try_from(&mut incoming).unwrap_or_default();
    logln!(1, "LOG", "Received request {}", incoming.url());
    let mut worker = shared_worker.lock().unwrap();
    let response = worker.handle(request);

    if let Err(error) = incoming.respond(response.into()) {
        logln!(1, "ERROR", "Failed response sending: {error}");
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use std::{net::TcpStream, time::Duration};

    #[test]
    fn starts_server_and_stops_on_shutdown_signal() {
        let worker = SharedWorker::default();
        let (shutdown, addr) = run_server(worker);

        assert!(TcpStream::connect_timeout(&addr, Duration::from_millis(50)).is_ok());

        let _ = shutdown.send(());

        std::thread::sleep(Duration::from_millis(6));
        assert!(TcpStream::connect_timeout(&addr, Duration::from_millis(50)).is_err());
    }
}