如何为HTTP服务器事件循环编写集成测试？

Question

在上以的方式为最终项目的基本示例：

use std::net::TcpListener;

mod server {
    fn run() {
        let listener = TcpListener::bind("127.0.0.1:7878").unwrap();

        for stream in listener.incoming() {
            let stream = stream.unwrap();

            println!("Connection established!");
        }
    }
}

我试图为该代码编写集成测试。 显然，我的测试正在运行到无限之外，因为TCP流提供的事件循环。

// tests/server.rs

#[test]
fn run() {
    server::run();

    // the rest of the code's test...
}

什么是测试服务器正确站立的好方法（无需收到任何请求），而无需更改公共接口以进行测试？

注意：没有任何类型的结果＆lt; t，e＆gt;都没有断言，因为我什至不知道如何为其运行的某些内容设置测试案例。

Answer 1

我不会从Rust内测试整个服务器，而是测试它的组件。我要测试的最高组件是一个连接。

RUST中的依赖性注入通常是这样工作的：

• 使用特征对于参数而不是特定对象类型
• 创建对象的模拟，该对象也实现了所需的特征，
• 使用模拟在我们的情况下在测试中创建所需的行为

，我将使用> io ::读取 + io ::写摘要tcpstream，因为这是我们使用的所有拟合。如果您需要进一步的功能，而不仅仅是这两个功能，则可能必须实现自己的networkStream：send + sync特征或类似性，您可以在其中代理tcpstream的进一步功能。 。

我将使用的模拟是 syncmockstream> syncmockstream href =“ https://crates.io/crates/mockstream/0.0.3” rel =“ nofollow noreferrer”> oberstream 板条箱。

对于以下示例，您需要将oigsstream添加到您的cargo.toml：

[dev-dependencies]
mockstream = "0.0.3"

首先，这是一个更简单的版本，只有io ::读取 + io：

mod server {
    use std::{io, net::TcpListener};

    fn handle_connection(
        mut stream: impl io::Read + io::Write,
    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
        println!("Connection established!");

        // Read 'hello'
        let mut buf = [0u8; 5];
        stream.read_exact(&mut buf)?;
        if &buf != b"hello" {
            return Err(format!("Received incorrect data: '{:?}'", buf).into());
        }

        println!("Received 'hello'. Sending 'world!' ...");

        // Respond with 'world!'
        stream.write_all(b"world!\n")?;
        stream.flush()?;

        println!("Communication finished. Closing connection ...");

        Ok(())
    }

    pub fn run(addr: &str) {
        let listener = TcpListener::bind(addr).unwrap();

        for stream in listener.incoming() {
            let stream = stream.unwrap();

            std::thread::spawn(move || {
                if let Err(e) = handle_connection(stream) {
                    println!("Connection closed with error: {}", e);
                } else {
                    println!("Connection closed.");
                }
            });
        }
    }

    #[cfg(test)]
    mod tests {
        use super::*;

        use mockstream::SyncMockStream;
        use std::time::Duration;

        #[test]
        fn hello_world_handshake() {
            // Arrange
            let mut stream = SyncMockStream::new();
            let connection = stream.clone();
            let connection_thread = std::thread::spawn(move || handle_connection(connection));

            // Act
            stream.push_bytes_to_read(b"hello");
            std::thread::sleep(Duration::from_millis(100));

            // Assert
            assert_eq!(stream.pop_bytes_written(), b"world!\n");
            connection_thread.join().unwrap().unwrap();
        }
    }
}

fn main() {
    server::run("127.0.0.1:7878");
}

> nc localhost 7878
hello
world!

> cargo test
running 1 test
test server::tests::hello_world_handshake ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.10s

现在，如果我们需要进一步的功能，例如发件人地址，我们可以介绍自己的特质networkStream：

mod traits {
    use std::io;

    pub trait NetworkStream: io::Read + io::Write {
        fn peer_addr_str(&self) -> io::Result<String>;
    }

    impl NetworkStream for std::net::TcpStream {
        fn peer_addr_str(&self) -> io::Result<String> {
            self.peer_addr().map(|addr| addr.to_string())
        }
    }
}

mod server {
    use crate::traits::NetworkStream;
    use std::net::TcpListener;

    fn handle_connection(
        mut stream: impl NetworkStream,
    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
        println!("Connection established!");

        // Read 'hello'
        let mut buf = [0u8; 5];
        stream.read_exact(&mut buf)?;
        if &buf != b"hello" {
            return Err(format!("Received incorrect data: '{:?}'", buf).into());
        }

        println!("Received 'hello'. Sending response ...");

        // Respond with 'world!'
        stream.write_all(format!("hello, {}!\n", stream.peer_addr_str()?).as_bytes())?;
        stream.flush()?;

        println!("Communication finished. Closing connection ...");

        Ok(())
    }

    pub fn run(addr: &str) {
        let listener = TcpListener::bind(addr).unwrap();

        for stream in listener.incoming() {
            let stream = stream.unwrap();

            std::thread::spawn(move || {
                if let Err(e) = handle_connection(stream) {
                    println!("Connection closed with error: {}", e);
                } else {
                    println!("Connection closed.");
                }
            });
        }
    }

    #[cfg(test)]
    mod tests {
        use super::*;

        use mockstream::SyncMockStream;
        use std::time::Duration;

        impl crate::traits::NetworkStream for SyncMockStream {
            fn peer_addr_str(&self) -> std::io::Result<String> {
                Ok("mock".to_string())
            }
        }

        #[test]
        fn hello_world_handshake() {
            // Arrange
            let mut stream = SyncMockStream::new();
            let connection = stream.clone();
            let connection_thread = std::thread::spawn(move || handle_connection(connection));

            // Act
            stream.push_bytes_to_read(b"hello");
            std::thread::sleep(Duration::from_millis(100));

            // Assert
            assert_eq!(stream.pop_bytes_written(), b"hello, mock!\n");
            connection_thread.join().unwrap().unwrap();
        }
    }
}

fn main() {
    server::run("127.0.0.1:7878");
}

> nc localhost 7878
hello
hello, 127.0.0.1:50718!

> cargo test
running 1 test
test server::tests::hello_world_handshake ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.12s

请注意，在这两种情况下，oigs> oigsstream依赖关系仅是需要作为dev依赖性。实际的货物构建不需要它。

---

集成测试

如果您想进一步测试整个服务器，我将把服务器视为黑匣子，然后使用外部工具进行测试，例如表现。

行为是基于Python和Gherkin的行为测试框架，非常适合黑匣子集成测试。

有了它，您可以运行货物构建产生的实际，无法锁定的可执行文件，然后使用真实连接测试实际功能。 表现对此非常出色，尤其是在弥合程序员和需求工程师之间的差距的情况下，因为实际的测试用例以书面的，非编程器可读的形式。