Easy switch between normal and debugging output

[fleetingbytes]

In my project's test source files I was spending more and more time switching between a normal cucumber output and an output allowing me to debug my tests (with tracing integration 💟 ). Since I don't like to allow unused imports I was often spending time adjusting, commenting, or uncommenting multiple use statements in addition to commenting and uncommenting big chunks of my cucumber's call in async fn main() {World::cucumber...}. And I had to do this across multiple test source files and keep the imports and calling code mutually in sync.

Now I think I have a solution where all it takes to switch between debug and normal output is to rewrite a single word in the code of a test source file. It goes like this:

This is my test helper crate test_utils.rs which defines the common things across my tests. It contains, among other things, this code:

// test_utils/src/lib.rs
use cucumber::{parser, runner, writer, Cucumber, World as _, WriterExt};
use futures::FutureExt as _;
use std::{io, path::Path};
use tracing_subscriber::{
    filter,
    fmt::format,
    layer::{Layer, SubscriberExt as _},
};

// my own World for the tests
#[derive(Debug, cucumber::World)]
#[world(init = Self::new)]
pub struct World { /* ... */ }

impl World {
    fn new() -> Self {
        Self { /* ... */ }
    }
}

// Cucumber with normal output
pub fn normal_world<I: AsRef<Path>>() -> cucumber::Cucumber<
    World,
    parser::Basic,
    I,
    runner::Basic<World>,
    writer::Summarize<writer::Normalize<World, writer::Basic>>,
> {
    World::cucumber()
        // add other settings here which you consider normal
}

// Cucumber with debugging output
pub fn debug_world<I: AsRef<Path>>() -> Cucumber<
    World,
    parser::Basic,
    I,
    runner::Basic<World>,
    writer::AssertNormalized<writer::Summarize<writer::Basic>>,
> {
    World::cucumber()
        // add your debugging settings here,
        // e.g. this tracing integration
        .max_concurrent_scenarios(1)
        .with_writer(
            writer::Basic::raw(io::stdout(), writer::Coloring::Never, 0)
                .summarized()
                .assert_normalized(),
        )
        .configure_and_init_tracing(
            format::DefaultFields::new(),
            format::Format::default(),
            |layer| {
                tracing_subscriber::registry()
                    .with(filter::LevelFilter::TRACE.and_then(layer))
            },
        )
}

Most crucially, test_utils defines the debug_world and the normal_world functions. I import them in my test source code like this

// project/tests/some_feature.rs
use test_utils::{debug_world as construct_world, World};

/*
 * implement some steps here
 */

#[tokio::main]
async fn main() {
    let world = construct_world();
    world.run("tests/features/some_feature.feature").await;
}

So now I can just change between normal and debug output by replacing the in debug_world as construct_world with normal_world as construct world. A lot of the import clutter is kept hidden in the test_utils crate.