How to expose running server and additional deps/data (so can be used in tests)

[kirillsalykin]

Hi,

I am following zero2prod (https://www.zero2prod.com/index.html) book and in one of the chapters they introduce Application struct:
https://github.com/kirillsalykin/zero-to-production/blob/main/src/startup.rs#L28

The Application struct is reused later in tests (it exposes server socket address and dbpool for instance).

Is something like this possible with axum? (and how?)

Taking into account that hyper is about to get rid of Server?

Thanks

(Disclaimer, I am just starting with rust)

[davidpdrsn]

Yes. Have a look at https://github.com/tokio-rs/axum/blob/main/examples/testing/src/main.rs

[kirillsalykin]

Thanks for such quick answer!

I might be mistaken but this one seems to use unreleased 0.7?
is it safe to use 0.7?

Also, while it does what I want - it is not exactly the same, there is a little duplication on how to start the server in main.rs/tests?

And sorry for the possibly stupid question, but is it possible to do like this:

struct HttpApi {
//     listener: SocketAddr,
    start: Box<dyn Fn() -> Server + Send + Sync>,
}
...
let start = async move {
            axum::Server::bind(&listener)
                .serve(app_closure())
                .await
                .unwrap()};
HttpApi { start }

?

(I do strugle with Server, cause it requires some generics from Hyper...)

Thanks

[davidpdrsn]

Sorry. Look at the example tagged with the version you’re using such as https://github.com/tokio-rs/axum/blob/axum-v0.6.20/examples/testing/src/main.rs

[kirillsalykin]

hi @davidpdrsn
I think I was able to achieve what I wanted:

pub struct HttpApi {
    pub server: JoinHandle<()>,
    pub addr: SocketAddr,
}

impl HttpApi {
    pub fn run(addr: &SocketAddr) -> Self {
        let query_root = QueryRoot {};
        let mutation_root = MutationRoot {};
        let schema = Schema::new(query_root, mutation_root, EmptySubscription);
        let router = Router::new()
            .route("/healthz", get(healthz))
            .route("/api", post(graphql_handler))
            .layer(Extension(schema));

        let listener = TcpListener::bind(addr).unwrap();
        let addr = listener.local_addr().unwrap();
        println!("listening on {}", addr);

        let server = tokio::spawn(async move {
            Server::from_tcp(listener)
                .unwrap()
                .serve(router.into_make_service())
                .await
                .unwrap();
        });

        HttpApi { addr, server }
    }

    // 0.7 release
    // let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
    //     .await
    //     .unwrap();
    // println!("listening on {}", listener.local_addr().unwrap());
    // axum::serve(listener, app).await.unwrap();
}

The key is JoinHandle, which starts the server in the background (and you can block your main).

Maybe it is worth to be included in the examples?

[davidpdrsn]

Not sure that's strictly better than returning the router from a function and running things from main. So I'd say we just keep the example as is.

[kirillsalykin]

sure
thanks!