Cucumber Testing with Rocket

[guenhter]

Hi,

I want to use Cucumber (https://github.com/cucumber-rs/cucumber) for testing my rocket app.

extern crate web_backend;

use cucumber::{gherkin::Step, then, when, World};
use rocket::local::asynchronous::Client as HttpClient;
use rocket::{futures, routes};

// `World` is your shared, likely mutable state.
// Cucumber constructs it via `Default::default()` for each scenario.
#[derive(Debug, World)]
#[world(init = Self::new)]
pub struct SettingsWorld {
    pub http_client: HttpClient,
}

impl SettingsWorld {
    async fn new() -> Self {
        let client = prepare_rocket_for_integration_test().await.unwrap();

        Self {
            http_client: client,
        }
    }
}

#[when(expr = "the http endpoint {string} is triggered")]
async fn trigger_http_endpoint(world: &mut SettingsWorld, endpoint: String) {
    let response = world.http_client.get(endpoint).dispatch().await;
}

#[then(expr = "the following json is received:")]
async fn the_result_json_is_equal_to(world: &mut SettingsWorld, step: &Step) {
    // Do some assertions
}

async fn prepare_rocket_for_integration_test() -> anyhow::Result<HttpClient> {
    let http_server = rocket::build().mount(
        "/api/v1/global/settings",
        routes![web_backend::settings::http::get_global_settings],
    );
    let http_client = HttpClient::tracked(http_server).await.unwrap();

    Ok(http_client)
}

fn main() {
    futures::executor::block_on(SettingsWorld::run("tests/features/settings.feature"));
}

This is already a working sample, but what I need is also to store the response to the SettingsWorld. This is where my problem begins, because the response needs a lifetime, and a "World" is not supposed to have a lifetime.

Any ideas how this idiomatically should work?

[SergioBenitez]

Can you elaborate on why you need to store the response? In general you can take the response and convert it into an owned value, like a string or a vector of bytes.

[guenhter]

Sure: In Cucumber you have a structure have the Given, When, Then pattern like

Given the backend is started
When the login endpoint is triggered
Then the status code is 200

This three steps are represented as standalone rust functions in the code and will be executed by the cucumber framework.
To share data between the steps, cucumber has the concept of "World". For each test, a new World is created and the same instance is then passed to all steps which are involved in the test. The world should be then mutated by steps.

In this example, the step "When the login endpoint is triggered" should set the response to the world and the step "Then the status code is 200" can then access the response and get out the status code.

For the moment, I have solved this that way, not to store the response in the World, but the status code, but this is less flexible.

[SergioBenitez]

Thanks for clarifying.

The response can have many references to the client and/or request. This will never change. We could theoretically provide a means to convert any response into an owned variant, but that seems error-prone.

What you're observing is the inability to have self-referential structures. This is very tricky. In my opinion, the cucumber pattern as implemented here doesn't make a lot of sense in Rust for this reason: you can never borrow between stages (cucumber-rs/cucumber#320). Doing this "right" and keeping the function-level separation on the cucumber side is difficult. More likely, you'd want to take a different approach to implementing the cucumber pattern in Rust altogether.

Unfortunately there's no efficient, good way to approach this. If you want to stick to using this crate, you'll need to extract the specific data you need at stage - 1 and convert it into an owned variant to be inspected at stage.

[guenhter]

Thanks for the good explanation. This seems very reasonable.
Extracting all the necessary fields and store them (without lifetime) in the "World" is absolutely good enough. Having the response instead would of course be nice, but if it is not practical, it is totally fine.
Thx for your time.