Unit testing 如何测试超服务器HTTP处理程序功能？

我的应用程序使用板条箱通过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请求调用此函数，提供

请求

请求

和

响应

res

变量

我想对我的

句柄

函数进行单元测试，因此我调用该函数，提供

请求

和

响应

，并断言

响应

已用于发送预期数据（“Hello”）

我试图实例化一个

请求

和一个

响应

对象，以传递到

句柄

函数中。为此，需要几个依赖项，我需要创建这些依赖项。为此，我最终实现了一个模拟的

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");
    }
}

---

我的模拟设置中的错误在哪里？有没有一种更直接的方法来测试这样一个处理函数，而不需要那么多样板代码？

请求解码器将期望找到一个由读取器提供的HTTP请求

你的读者提供。。。没有什么。显然，这将导致解析器失败。

在@Matthieu和@Shepmaster输入的基础上回答我自己的问题

我从中复制了

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"));
}

---

这些都不是很好的

读
和
写
。。。这可能会导致其他问题。这很难看，但您可以复制的内部实现。我理解这个问题，谢谢。但是，如果我尝试
let request=hyper:：server:：request:：new（b“GET/HTTP/1.0\r\n\r\n”，socket）.unwrap（），编译器将抱怨不匹配的类型：预期类型
&mut hyper:：buffer:：BufReader@pixelistik：是的，对不起。看起来比这更具体，我将删除这个建议。
#[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"));
}