Merge pull request #751 from lann/tracing-testing

Use tracing TestWriter in tests

Author: lann

Cargo.lock

@@ -405,7 +405,7 @@ pub(crate) trait HttpExecutor: Clone + Send + Sync + 'static {
 
 #[cfg(test)]
 mod tests {
-    use std::{collections::BTreeMap, sync::Once};
+    use std::collections::BTreeMap;
 
     use anyhow::Result;
     use spin_manifest::{HttpConfig, HttpExecutor};
@@ -414,18 +414,6 @@ mod tests {
 
     use super::*;
 
-    static LOGGER: Once = Once::new();
-
-    /// We can only initialize the tracing subscriber once per crate.
-    pub(crate) fn init() {
-        LOGGER.call_once(|| {
-            tracing_subscriber::fmt()
-                .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
-                .with_ansi(atty::is(atty::Stream::Stderr))
-                .init();
-        });
-    }
-
     #[test]
     fn test_default_headers_with_base_path() -> Result<()> {
         let scheme = "https";
@@ -525,8 +513,6 @@ mod tests {
         Ok(())
     }
 
-    // fn _search(key: &str, headers: &[(String, String)]) -> Option<String> {}
-
     fn search<'a>(keys: &'a [&'a str], headers: &[(&[&str], String)]) -> Option<String> {
         let mut res: Option<String> = None;
         for (k, v) in headers {
@@ -540,8 +526,6 @@ mod tests {
 
     #[tokio::test]
     async fn test_spin_http() -> Result<()> {
-        init();
-
         let mut cfg = spin_testing::TestConfig::default();
         cfg.test_program("rust-http-test.wasm")
             .http_trigger(HttpConfig {
@@ -571,8 +555,6 @@ mod tests {
 
     #[tokio::test]
     async fn test_wagi_http() -> Result<()> {
-        init();
-
         let mut cfg = spin_testing::TestConfig::default();
         cfg.test_program("wagi-test.wasm").http_trigger(HttpConfig {
             route: "/test".to_string(),

crates/http/src/lib.rs

@@ -144,12 +144,13 @@ impl fmt::Display for RoutePattern {
 
 #[cfg(test)]
 mod route_tests {
+    use spin_testing::init_tracing;
+
     use super::*;
-    use crate::tests::init;
 
     #[test]
     fn test_exact_route() {
-        init();
+        init_tracing();
 
         let rp = RoutePattern::from("/", "/foo/bar");
         assert!(rp.matches("/foo/bar"));

crates/http/src/routes.rs

@@ -4,18 +4,6 @@ use redis::{Msg, Value};
 use spin_manifest::{RedisConfig, RedisExecutor};
 use spin_testing::TestConfig;
 use spin_trigger::TriggerExecutorBuilder;
-use std::sync::Once;
-
-static LOGGER: Once = Once::new();
-
-/// We can only initialize the tracing subscriber once per crate.
-pub(crate) fn init() {
-    LOGGER.call_once(|| {
-        tracing_subscriber::fmt()
-            .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
-            .init();
-    });
-}
 
 fn create_trigger_event(channel: &str, payload: &str) -> redis::Msg {
     Msg::from_value(&redis::Value::Bulk(vec![
@@ -29,8 +17,6 @@ fn create_trigger_event(channel: &str, payload: &str) -> redis::Msg {
 #[ignore]
 #[tokio::test]
 async fn test_pubsub() -> Result<()> {
-    init();
-
     let mut cfg = TestConfig::default();
     cfg.test_program("redis-rust.wasm")
         .redis_trigger(RedisConfig {

crates/redis/src/tests.rs

@@ -12,3 +12,4 @@ spin-engine = { path = "../engine" }
 spin-manifest = { path = "../manifest" }
 spin-http-engine = { path = "../http" }
 spin-trigger = { path = "../trigger" }
+tracing-subscriber = "0.3"

crates/testing/Cargo.toml

@@ -4,18 +4,26 @@
 use std::{
     net::SocketAddr,
     path::{Path, PathBuf},
+    sync::Once,
 };
 
-use http::{uri::Scheme, Request, Response};
+use http::Response;
 use hyper::Body;
-use spin_engine::{Builder, ExecutionContextConfiguration};
 use spin_http_engine::HttpTrigger;
 use spin_manifest::{
     Application, ApplicationInformation, ApplicationOrigin, ApplicationTrigger, CoreComponent,
     HttpConfig, ModuleSource, RedisConfig, RedisTriggerConfiguration, SpinVersion, TriggerConfig,
 };
 use spin_trigger::TriggerExecutorBuilder;
 
+/// Initialize a test writer for `tracing`, making its output compatible with libtest
+pub fn init_tracing() {
+    static ONCE: Once = Once::new();
+    ONCE.call_once(|| {
+        tracing_subscriber::fmt().with_test_writer().init();
+    })
+}
+
 #[derive(Default)]
 pub struct TestConfig {
     module_path: Option<PathBuf>,
@@ -25,6 +33,7 @@ pub struct TestConfig {
 
 impl TestConfig {
     pub fn module_path(&mut self, path: impl Into<PathBuf>) -> &mut Self {
+        init_tracing();
         self.module_path = Some(path.into());
         self
     }
@@ -99,33 +108,12 @@ impl TestConfig {
         }
     }
 
-    pub async fn prepare_builder<T: Default + Send + 'static>(
-        &self,
-        app: Application,
-    ) -> Builder<T> {
-        let config = ExecutionContextConfiguration {
-            components: app.components,
-            label: app.info.name,
-            ..Default::default()
-        };
-        let mut builder = Builder::new(config).expect("Builder::new failed");
-        builder.link_defaults().expect("link_defaults failed");
-        builder
-    }
-
     pub async fn build_http_trigger(&self) -> HttpTrigger {
         TriggerExecutorBuilder::new(self.build_application())
             .build()
             .await
             .unwrap()
     }
-
-    pub async fn handle_http_request(&self, req: Request<Body>) -> anyhow::Result<Response<Body>> {
-        self.build_http_trigger()
-            .await
-            .handle(req, Scheme::HTTP, test_socket_addr())
-            .await
-    }
 }
 
 pub fn test_socket_addr() -> SocketAddr {