Function tcp_echo_server

test-programs/tests/tcp_echo_server.rs:5–84

()

#[test_log::test]
fn tcp_echo_server() -> Result<()> {
    use std::io::{Read, Write};
    use std::net::{Shutdown, TcpStream};

    println!("testing {}", test_programs::TCP_ECHO_SERVER);

    // Run the component in wasmtime
    // -Sinherit-network required for sockets to work
    let mut wasmtime_process = Command::new("wasmtime")
        .arg("run")
        .arg("-Sinherit-network")
        .arg(test_programs::TCP_ECHO_SERVER)
        .stdout(std::process::Stdio::piped())
        .spawn()?;

    let addr = get_listening_address(wasmtime_process.stdout.take().expect("stdout is piped"))?;

    println!("tcp echo server is listening on {addr:?}");

    let mut sock1 = TcpStream::connect(addr).context("connect sock1")?;
    println!("sock1 connected");

    let mut sock2 = TcpStream::connect(addr).context("connect sock2")?;
    println!("sock2 connected");

    const MESSAGE1: &[u8] = b"hello, echoserver!\n";

    sock1.write_all(MESSAGE1).context("write to sock1")?;
    println!("sock1 wrote to echo server");

    let mut sock3 = TcpStream::connect(addr).context("connect sock3")?;
    println!("sock3 connected");

    const MESSAGE2: &[u8] = b"hello, gussie!\n";
    sock2.write_all(MESSAGE2).context("write to sock1")?;
    println!("sock2 wrote to echo server");

    sock1.shutdown(Shutdown::Write)?;
    sock2.shutdown(Shutdown::Write)?;

    let mut readback2 = Vec::new();
    sock2
        .read_to_end(&mut readback2)
        .context("read from sock2")?;
    println!("read from sock2");

    let mut readback1 = Vec::new();
    sock1
        .read_to_end(&mut readback1)
        .context("read from sock1")?;
    println!("read from sock1");

    assert_eq!(MESSAGE1, readback1, "readback of sock1");
    assert_eq!(MESSAGE2, readback2, "readback of sock2");

    let mut sock4 = TcpStream::connect(addr).context("connect sock4")?;
    println!("sock4 connected");
    const MESSAGE4: &[u8] = b"hello, sparky!\n";