Inject an HTTP Client

[guenhter]

Hi,

my http get endpoint itself need the ability to make http requests to other resources and therefore needs an http client.
It is indeed possible to just instantiate a new http client within my get endpoint like this;

#[get("/")]
async fn index() -> Result<String, Error> {
    let client = reqwest::Client::new();
    ...
}

But I don't know if this is good idea and from a testing point of view it is also not ideal because the client should be easy to mock.

IMO something like this would be great to have:

#[get("/")]
async fn index(client: Client) -> Result<String, Error> {
    ...
}

then the framework is responsible for managing the http client and tests could just exchange the client with a mock.

Is there something like this?

[SergioBenitez]

Yes: managed state.

[guenhter]

What I had in mind is something like this:

#[macro_use]
extern crate rocket;

use rocket::request::{self, Request};

trait MyService<'r> {
    fn perform(&self) -> String;
}

struct MyServiceFactory {}

impl<'r> MyServiceFactory {
    async fn from_request(
        request: &'r Request<'_>,
    ) -> request::Outcome<Box<dyn MyService<'r>>, ()> {
        let db = request.guard::<Database>().await.succeeded()?;

        // Create a concreate `MyService` with a the DB
        // The service instance is then only valid for this request
    }
}

#[get("/hello/<name>/<age>")]
fn hello(name: &str, age: u8, service: Box<dyn MyService>) -> String {
    let result = service.perform();
    format!("Hello, {} year old named {}!", age, result)
}

#[launch]
fn rocket() -> _ {
    ...
    rocket::build()
        .attach(Database::init())
        .manage(MyServiceFactory {})
        .mount("/", routes![hello])
}

The MyServiceFactory is here to construct MyService (which itself is a trait).
In this mechanism, the actual State/Guard is not needed to be known at compile time but can be exchanged. E.g. for productoin I can have a different MyService implementation as for staging or testing.

In my concreate use case I need to have a different "Service" for testing and production. This would be a nice and elegant way to solve this.

[the10thWiz]

In this mechanism, the actual State/Guard is not needed to be known at compile time

This isn't possible. The code generation emits code to construct the guard, using the guard type to identify which implementation to call. Rust, because it's a fully compiled language, doesn't support swapping out an implementation without recompiling.

From what it sounds like, you're looking to switch server you make requests against - why not just make it a configuration option, and extract it from the Rocket.toml?

[SergioBenitez]

This is possible. You just need to implement FromRequest for your Box<dyn Foo> type.