Question

我的应用程序使用hyper包来通过HTTP提供一些数据。核心是一个处理函数，如下所示：

struct HttpHandler {}

impl hyper::server::Handler for HttpHandler {
    fn handle(&self, req: hyper::server::Request, res: hyper::server::Response) {
        res.send(b"Hello").unwrap();
    }
}

Hyper会为每个HTTP请求调用此函数，提供Request req和Response res个变量。

我想对我的handle函数进行单元测试，因此我调用该函数，提供Request和Response，并断言Response已用于发送预期数据（＆＃34; Hello＆＃34;）。

我试图实例化Request和Response对象，以传入handle函数。为此，需要几个依赖项，我需要创建它们。为此，我最终实现了模拟NetworkStream：

mod tests {
    use std::io;
    use std::io::prelude::*;
    use std::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4};
    use std::time::Duration;
    use hyper::server::Handler;

    use super::*;

    struct MockNetworkStream {}

    impl Read for MockNetworkStream {
        fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
            Ok(1)
        }
    }

    impl Write for MockNetworkStream {
        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
            Ok(1)
        }

        fn flush(&mut self) -> io::Result<()> {
            Ok(())
        }
    }

    impl hyper::net::NetworkStream for MockNetworkStream {
        fn peer_addr(&mut self) -> Result<SocketAddr, io::Error> {
            Ok(SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080)))
        }

        fn set_read_timeout(&self, dur: Option<Duration>) -> Result<(), io::Error> {
            Ok(())
        }

        fn set_write_timeout(&self, dur: Option<Duration>) -> Result<(), io::Error> {
            Ok(())
        }
    }

    #[test]
    fn test_handle() {
        let handler = HttpHandler {};

        let mut request_mock_network_stream = MockNetworkStream {};

        let mut reader = hyper::buffer::BufReader::new(&mut request_mock_network_stream as
                                                       &mut hyper::net::NetworkStream);

        let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);

        // The following fails with
        //    'tests::test_handle' panicked at 'called `Result::unwrap()` on an `Err` value: Header'
        let request = hyper::server::Request::new(&mut reader, socket).unwrap();

        let mut headers = hyper::header::Headers::new();
        let mut response_mock_network_stream = MockNetworkStream {};
        let response = hyper::server::Response::new(&mut response_mock_network_stream,
                                                    &mut headers);

        handler.handle(request, response);

        // I would like to do some assert like this:
        // assert_eq!(result, b"Hello");
    }
}

Full runnable playground example

然而，实例化Request恐慌：

// The following fails with
//    'tests::test_handle' panicked at 'called `Result::unwrap()` on an `Err` value: Header'
let request = hyper::server::Request::new(&mut reader, socket).unwrap();

我的模拟设置中的错误在哪里？在没有太多样板代码的情况下，是否有更直接的方法来测试这样的处理函数？

Answer 1

请求解码器期望找到由读者提供的HTTP请求。

您的读者提供了...... 没有。显然这会导致解析器失败。

Answer 2

根据@Matthieu和@Shepmaster的意见回答我自己的问题。

我从Hyper code复制了MockStream实施，而不是自己构建。

使用它，我现在可以做我想要的事情：检查我的HTTP响应是否包含预期的术语：

#[test]
fn test_handle() {
    let handler = HttpHandler {};

    // Create a minimal HTTP request
    let mut request_mock_network_stream = MockStream::with_input(b"GET / HTTP/1.0\r\n\r\n");

    let mut reader = hyper::buffer::BufReader::new(&mut request_mock_network_stream as
                                                   &mut hyper::net::NetworkStream);

    let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);

    let request = hyper::server::Request::new(&mut reader, socket).unwrap();

    let mut headers = hyper::header::Headers::new();
    let mut response_mock_network_stream = MockStream::new();

    {
        let response = hyper::server::Response::new(&mut response_mock_network_stream,
                                                    &mut headers);

        handler.handle(request, response);
    }

    let result = str::from_utf8(&response_mock_network_stream.write).unwrap();

    assert!(result.contains("Hello"));
}

Full runnable code

如何测试Hyper服务器HTTP处理函数？

2 个答案: