如何在Cucumber-RS测试的不同步骤中验证Trace日志是否输出？

要实现跨测试步骤验证Trace日志，最直接的方式是基于tracing-subscriber自定义一个日志收集层（Layer），将日志事件暂存到可跨步骤访问的共享存储中。这样触发日志的测试步骤和后续验证步骤可以共用这个存储，完成日志校验。

1. 添加依赖 #

在Cargo.toml中添加必要依赖：

[dependencies]
tracing = "0.1"

[dev-dependencies]
tracing-subscriber = "0.3"
tokio = { version = "1.0", features = ["full"] } # 异步测试场景需要

2. 自定义日志收集Layer #

创建线程安全的共享日志存储，搭配tracing-subscriber的Layer实现日志收集：

use std::sync::{Arc, Mutex};
use tracing::{Event, Level, Metadata};
use tracing_subscriber::layer::Context;
use tracing_subscriber::Layer;

// 共享日志存储，支持跨步骤访问
#[derive(Clone, Default)]
pub struct LogStore {
    events: Arc<Mutex<Vec<Event<'static>>>>,
}

impl LogStore {
    // 清空存储，保证测试隔离
    pub fn clear(&self) {
        self.events.lock().unwrap().clear();
    }

    // 获取所有收集到的日志事件
    pub fn events(&self) -> Vec<Event<'static>> {
        self.events.lock().unwrap().clone()
    }

    // 检查是否包含指定内容的Trace日志
    pub fn contains_trace(&self, target_msg: &str) -> bool {
        self.events().into_iter().any(|event| {
            event.metadata().level() == &Level::TRACE &&
            // 提取日志消息，可根据项目实际格式化逻辑调整
            format!("{}", event.fields()).contains(target_msg)
        })
    }
}

// 实现tracing的Layer trait，将日志事件存入LogStore
impl<S> Layer<S> for LogStore
where
    S: tracing_subscriber::Subscriber,
{
    fn on_event(&self, event: &Event<'_>, _ctx: Context<'_, S>) {
        // 将事件转为'static生命周期（简化实现，生产环境可优化）
        let cloned_event = std::mem::transmute_copy(event);
        self.events.lock().unwrap().push(cloned_event);
    }
}

3. 集成到普通集成测试 #

在tests/integration_test.rs中编写跨步骤的测试逻辑：

use your_crate::{LogStore, some_function_that_emits_trace};
use tracing_subscriber::util::SubscriberInitExt;

#[test]
fn test_trace_log_across_steps() {
    // 初始化日志收集器
    let log_store = LogStore::default();
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::TRACE)
        .with_layer(log_store.clone())
        .init();

    // 步骤1：触发日志输出
    some_function_that_emits_trace("test_trace_content");

    // 步骤2：验证日志存在
    assert!(log_store.contains_trace("test_trace_content"));

    // 清空存储，避免影响其他测试
    log_store.clear();
}

4. 结合cucumber-rs的BDD测试场景 #

如果用cucumber-rs做BDD测试，可将LogStore放入World结构体，实现步骤间状态共享：

use cucumber::{World, Given, When, Then};
use your_crate::{LogStore, some_function_that_emits_trace};
use tracing_subscriber::util::SubscriberInitExt;

#[derive(Debug, Clone, World)]
pub struct TestWorld {
    log_store: LogStore,
}

impl Default for TestWorld {
    fn default() -> Self {
        let log_store = LogStore::default();
        tracing_subscriber::fmt()
            .with_max_level(tracing::Level::TRACE)
            .with_layer(log_store.clone())
            .init();
        Self { log_store }
    }
}

#[Given("系统已就绪")]
fn system_ready(world: &mut TestWorld) {
    // 前置操作：清空日志存储
    world.log_store.clear();
}

#[When("执行触发Trace日志的操作，内容为{string}")]
fn perform_action(world: &mut TestWorld, msg: String) {
    some_function_that_emits_trace(&msg);
}

#[Then("Trace日志中应包含{string}")]
fn verify_trace_log(world: &mut TestWorld, msg: String) {
    assert!(world.log_store.contains_trace(&msg));
}

注意事项 #

• 测试隔离：每个测试前调用log_store.clear()，避免不同测试的日志互相干扰。
• 异步适配：异步测试场景下，建议用tokio::sync::Mutex替代std::sync::Mutex，确保线程安全。
• 日志提取优化：如果项目中用tracing::trace!("msg: {}", content)这类格式化日志，可直接通过event.field("content")提取字段值，比格式化字符串更高效准确。

内容的提问来源于stack exchange，提问作者fleetingbytes