Testing with into_make_service_with_connect_info

[tgecho]

I have been testing happily enough with something resembling the following:

let app: Router = build_app(/* details elided */);
let resp = app.oneshot(Request::builder().uri(uri).body(Body::empty()).unwrap()).await.unwrap();

But then I needed to extract ConnectInfo<SocketAddr> in one of my routes, so I needed to start using https://docs.rs/axum/latest/axum/routing/struct.Router.html#method.into_make_service_with_connect_info. This caused the tests of the ConnectInfo dependent route to fail with 500 statuses.

After figuring out that it was the missing ConnectInfo (which generally makes sense as there isn't a connection) and trying to figure out how to inject one manually for testing, I came across this thread on testing docs and adapted it into something like this:

Updated listener creation to use port :0 instead of portpicker based on the "real" test example.

use my_app::build_app;
use std::net::{SocketAddr, TcpListener};
use tokio::task::JoinHandle;
use url::Url;

pub struct TestApp {
    pub base_url: Url,
    pub client: reqwest::Client,
    server: JoinHandle<()>,
}

impl TestApp {
    pub async fn new() -> TestApp {
        let app: Router = build_app(/* details elided */);

        let listener = TcpListener::bind("127.0.0.1:0").expect("Could not bind ephemeral socket");
        let addr = listener.local_addr().unwrap();
        let server = tokio::spawn(async move {
            axum::Server::from_tcp(listener)
                .unwrap()
                .serve(app.into_make_service_with_connect_info::<SocketAddr, _>())
                .await
                .unwrap();
        });

        TestApp {
            base_url: Url::parse(&format!("http://{addr}")).unwrap(),
            client: reqwest::Client::new(),
            server,
        }
    }

    pub fn get(&self, path: &str) -> reqwest::RequestBuilder {
        let base_url = Some(&self.base_url);
        let base = Url::options().base_url(base_url);
        let url = base.parse(path).unwrap();
        self.client.get(url)
    }
}

impl Drop for TestApp {
    fn drop(&mut self) {
        tracing::debug!("Dropping test server at {}", self.base_url.as_str());
        self.server.abort()
    }
}

Usage:

let app = TestApp::new().await;
let response = app.get(&path).send().await.unwrap();

To be clear, I don't think this is terrible! It's all pretty much done once, using reqwest as a client is a bit more ergonomic anyway, and we're actually testing more of the stack. However, I can't help but wonder if it's a little overkill.

Any thoughts?

[davidpdrsn]

Overkill how? It's how we test axum internally and we've had no issues with it.

So seems fine to me 😊

Whilst I wouldn't recommend it a different way of "faking a connection" is that you manually insert a ConnectInfo of the right type as an extension on the test request. The 500 you're seeing comes from the extension not being set. I wouldn't recommend this because there is no guarantee the internals won't change in the future, although we have no such plans currently.

[tgecho]

I mostly wondered because it's a fair bit more ceremony then the testing example. I'm totally on board with keeping the internals internal. Thanks!

[davidpdrsn]

Thats true but if you remove TestApp (which I think is a worthy abstraction) then you're basically left with this example.

[tgecho]

See, I was going to say that I'd meant to link to that example file as if I'd read it (which I did!), but I did not actually read all the way to the bottom to see that final/"real" version 🤦

Hopefully my stumbling around will at least serve to provide someone else with a useful search result. Thanks again! 😁