diff options
Diffstat (limited to 'vendor/tracing-subscriber/tests/layer_filters')
8 files changed, 0 insertions, 797 deletions
diff --git a/vendor/tracing-subscriber/tests/layer_filters/boxed.rs b/vendor/tracing-subscriber/tests/layer_filters/boxed.rs deleted file mode 100644 index 0fe37188e..000000000 --- a/vendor/tracing-subscriber/tests/layer_filters/boxed.rs +++ /dev/null @@ -1,42 +0,0 @@ -use super::*; -use tracing_subscriber::{filter, prelude::*, Layer}; - -fn layer() -> (ExpectLayer, subscriber::MockHandle) { - layer::mock().done().run_with_handle() -} - -fn filter<S>() -> filter::DynFilterFn<S> { - // Use dynamic filter fn to disable interest caching and max-level hints, - // allowing us to put all of these tests in the same file. - filter::dynamic_filter_fn(|_, _| false) -} - -/// reproduces https://github.com/tokio-rs/tracing/issues/1563#issuecomment-921363629 -#[test] -fn box_works() { - let (layer, handle) = layer(); - let layer = Box::new(layer.with_filter(filter())); - - let _guard = tracing_subscriber::registry().with(layer).set_default(); - - for i in 0..2 { - tracing::info!(i); - } - - handle.assert_finished(); -} - -/// the same as `box_works` but with a type-erased `Box`. -#[test] -fn dyn_box_works() { - let (layer, handle) = layer(); - let layer: Box<dyn Layer<_> + Send + Sync + 'static> = Box::new(layer.with_filter(filter())); - - let _guard = tracing_subscriber::registry().with(layer).set_default(); - - for i in 0..2 { - tracing::info!(i); - } - - handle.assert_finished(); -} diff --git a/vendor/tracing-subscriber/tests/layer_filters/combinators.rs b/vendor/tracing-subscriber/tests/layer_filters/combinators.rs deleted file mode 100644 index 6052a2d00..000000000 --- a/vendor/tracing-subscriber/tests/layer_filters/combinators.rs +++ /dev/null @@ -1,42 +0,0 @@ -use super::*; -use tracing_subscriber::{ - filter::{filter_fn, FilterExt, LevelFilter}, - prelude::*, -}; - -#[test] -fn and() { - let (layer, handle) = layer::mock() - .event( - event::msg("a very interesting event") - .at_level(tracing::Level::INFO) - .with_target("interesting_target"), - ) - .done() - .run_with_handle(); - - // Enables spans and events with targets starting with `interesting_target`: - let target_filter = filter::filter_fn(|meta| meta.target().starts_with("interesting_target")); - - // Enables spans and events with levels `INFO` and below: - let level_filter = LevelFilter::INFO; - - // Combine the two filters together, returning a filter that only enables - // spans and events that *both* filters will enable: - let filter = target_filter.and(level_filter); - - let _subscriber = tracing_subscriber::registry() - .with(layer.with_filter(filter)) - .set_default(); - - // This event will *not* be enabled: - tracing::info!("an event with an uninteresting target"); - - // This event *will* be enabled: - tracing::info!(target: "interesting_target", "a very interesting event"); - - // This event will *not* be enabled: - tracing::debug!(target: "interesting_target", "interesting debug event..."); - - handle.assert_finished(); -} diff --git a/vendor/tracing-subscriber/tests/layer_filters/downcast_raw.rs b/vendor/tracing-subscriber/tests/layer_filters/downcast_raw.rs deleted file mode 100644 index b5f7e35ce..000000000 --- a/vendor/tracing-subscriber/tests/layer_filters/downcast_raw.rs +++ /dev/null @@ -1,68 +0,0 @@ -use tracing::Subscriber; -use tracing_subscriber::filter::Targets; -use tracing_subscriber::prelude::*; -use tracing_subscriber::Layer; - -#[test] -fn downcast_ref_to_inner_layer_and_filter() { - // Test that a filtered layer gives downcast_ref access to - // both the layer and the filter. - - struct WrappedLayer; - - impl<S> Layer<S> for WrappedLayer - where - S: Subscriber, - S: for<'lookup> tracing_subscriber::registry::LookupSpan<'lookup>, - { - } - - let layer = WrappedLayer; - let filter = Targets::new().with_default(tracing::Level::INFO); - let registry = tracing_subscriber::registry().with(layer.with_filter(filter)); - let dispatch = tracing::dispatcher::Dispatch::new(registry); - - // The filter is available - assert!(dispatch.downcast_ref::<Targets>().is_some()); - // The wrapped layer is available - assert!(dispatch.downcast_ref::<WrappedLayer>().is_some()); -} - -#[test] -fn forward_downcast_raw_to_layer() { - // Test that a filtered layer still gives its wrapped layer a chance to - // return a custom struct from downcast_raw. - // https://github.com/tokio-rs/tracing/issues/1618 - - struct WrappedLayer { - with_context: WithContext, - } - - struct WithContext; - - impl<S> Layer<S> for WrappedLayer - where - S: Subscriber, - S: for<'lookup> tracing_subscriber::registry::LookupSpan<'lookup>, - { - unsafe fn downcast_raw(&self, id: std::any::TypeId) -> Option<*const ()> { - match id { - id if id == std::any::TypeId::of::<Self>() => Some(self as *const _ as *const ()), - id if id == std::any::TypeId::of::<WithContext>() => { - Some(&self.with_context as *const _ as *const ()) - } - _ => None, - } - } - } - - let layer = WrappedLayer { - with_context: WithContext, - }; - let filter = Targets::new().with_default(tracing::Level::INFO); - let registry = tracing_subscriber::registry().with(layer.with_filter(filter)); - let dispatch = tracing::dispatcher::Dispatch::new(registry); - - // Types from a custom implementation of `downcast_raw` are available - assert!(dispatch.downcast_ref::<WithContext>().is_some()); -} diff --git a/vendor/tracing-subscriber/tests/layer_filters/filter_scopes.rs b/vendor/tracing-subscriber/tests/layer_filters/filter_scopes.rs deleted file mode 100644 index 7fd7d843b..000000000 --- a/vendor/tracing-subscriber/tests/layer_filters/filter_scopes.rs +++ /dev/null @@ -1,131 +0,0 @@ -use super::*; - -#[test] -fn filters_span_scopes() { - let (debug_layer, debug_handle) = layer::named("debug") - .enter(span::mock().at_level(Level::DEBUG)) - .enter(span::mock().at_level(Level::INFO)) - .enter(span::mock().at_level(Level::WARN)) - .enter(span::mock().at_level(Level::ERROR)) - .event(event::msg("hello world").in_scope(vec![ - span::mock().at_level(Level::ERROR), - span::mock().at_level(Level::WARN), - span::mock().at_level(Level::INFO), - span::mock().at_level(Level::DEBUG), - ])) - .exit(span::mock().at_level(Level::ERROR)) - .exit(span::mock().at_level(Level::WARN)) - .exit(span::mock().at_level(Level::INFO)) - .exit(span::mock().at_level(Level::DEBUG)) - .done() - .run_with_handle(); - let (info_layer, info_handle) = layer::named("info") - .enter(span::mock().at_level(Level::INFO)) - .enter(span::mock().at_level(Level::WARN)) - .enter(span::mock().at_level(Level::ERROR)) - .event(event::msg("hello world").in_scope(vec![ - span::mock().at_level(Level::ERROR), - span::mock().at_level(Level::WARN), - span::mock().at_level(Level::INFO), - ])) - .exit(span::mock().at_level(Level::ERROR)) - .exit(span::mock().at_level(Level::WARN)) - .exit(span::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - let (warn_layer, warn_handle) = layer::named("warn") - .enter(span::mock().at_level(Level::WARN)) - .enter(span::mock().at_level(Level::ERROR)) - .event(event::msg("hello world").in_scope(vec![ - span::mock().at_level(Level::ERROR), - span::mock().at_level(Level::WARN), - ])) - .exit(span::mock().at_level(Level::ERROR)) - .exit(span::mock().at_level(Level::WARN)) - .done() - .run_with_handle(); - - let _subscriber = tracing_subscriber::registry() - .with(debug_layer.with_filter(LevelFilter::DEBUG)) - .with(info_layer.with_filter(LevelFilter::INFO)) - .with(warn_layer.with_filter(LevelFilter::WARN)) - .set_default(); - - { - let _trace = tracing::trace_span!("my_span").entered(); - let _debug = tracing::debug_span!("my_span").entered(); - let _info = tracing::info_span!("my_span").entered(); - let _warn = tracing::warn_span!("my_span").entered(); - let _error = tracing::error_span!("my_span").entered(); - tracing::error!("hello world"); - } - - debug_handle.assert_finished(); - info_handle.assert_finished(); - warn_handle.assert_finished(); -} - -#[test] -fn filters_interleaved_span_scopes() { - fn target_layer(target: &'static str) -> (ExpectLayer, subscriber::MockHandle) { - layer::named(format!("target_{}", target)) - .enter(span::mock().with_target(target)) - .enter(span::mock().with_target(target)) - .event(event::msg("hello world").in_scope(vec![ - span::mock().with_target(target), - span::mock().with_target(target), - ])) - .event( - event::msg("hello to my target") - .in_scope(vec![ - span::mock().with_target(target), - span::mock().with_target(target), - ]) - .with_target(target), - ) - .exit(span::mock().with_target(target)) - .exit(span::mock().with_target(target)) - .done() - .run_with_handle() - } - - let (a_layer, a_handle) = target_layer("a"); - let (b_layer, b_handle) = target_layer("b"); - let (all_layer, all_handle) = layer::named("all") - .enter(span::mock().with_target("b")) - .enter(span::mock().with_target("a")) - .event(event::msg("hello world").in_scope(vec![ - span::mock().with_target("a"), - span::mock().with_target("b"), - ])) - .exit(span::mock().with_target("a")) - .exit(span::mock().with_target("b")) - .done() - .run_with_handle(); - - let _subscriber = tracing_subscriber::registry() - .with(all_layer.with_filter(LevelFilter::INFO)) - .with(a_layer.with_filter(filter::filter_fn(|meta| { - let target = meta.target(); - target == "a" || target == module_path!() - }))) - .with(b_layer.with_filter(filter::filter_fn(|meta| { - let target = meta.target(); - target == "b" || target == module_path!() - }))) - .set_default(); - - { - let _a1 = tracing::trace_span!(target: "a", "a/trace").entered(); - let _b1 = tracing::info_span!(target: "b", "b/info").entered(); - let _a2 = tracing::info_span!(target: "a", "a/info").entered(); - let _b2 = tracing::trace_span!(target: "b", "b/trace").entered(); - tracing::info!("hello world"); - tracing::debug!(target: "a", "hello to my target"); - tracing::debug!(target: "b", "hello to my target"); - } - - a_handle.assert_finished(); - b_handle.assert_finished(); - all_handle.assert_finished(); -} diff --git a/vendor/tracing-subscriber/tests/layer_filters/main.rs b/vendor/tracing-subscriber/tests/layer_filters/main.rs deleted file mode 100644 index 0233f063b..000000000 --- a/vendor/tracing-subscriber/tests/layer_filters/main.rs +++ /dev/null @@ -1,189 +0,0 @@ -#![cfg(feature = "registry")] -#[path = "../support.rs"] -mod support; -use self::support::*; -mod boxed; -mod downcast_raw; -mod filter_scopes; -mod targets; -mod trees; -mod vec; - -use tracing::{level_filters::LevelFilter, Level}; -use tracing_subscriber::{filter, prelude::*, Layer}; - -#[test] -fn basic_layer_filters() { - let (trace_layer, trace_handle) = layer::named("trace") - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - - let (debug_layer, debug_handle) = layer::named("debug") - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - - let (info_layer, info_handle) = layer::named("info") - .event(event::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - - let _subscriber = tracing_subscriber::registry() - .with(trace_layer.with_filter(LevelFilter::TRACE)) - .with(debug_layer.with_filter(LevelFilter::DEBUG)) - .with(info_layer.with_filter(LevelFilter::INFO)) - .set_default(); - - tracing::trace!("hello trace"); - tracing::debug!("hello debug"); - tracing::info!("hello info"); - - trace_handle.assert_finished(); - debug_handle.assert_finished(); - info_handle.assert_finished(); -} - -#[test] -fn basic_layer_filters_spans() { - let (trace_layer, trace_handle) = layer::named("trace") - .new_span(span::mock().at_level(Level::TRACE)) - .new_span(span::mock().at_level(Level::DEBUG)) - .new_span(span::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - - let (debug_layer, debug_handle) = layer::named("debug") - .new_span(span::mock().at_level(Level::DEBUG)) - .new_span(span::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - - let (info_layer, info_handle) = layer::named("info") - .new_span(span::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - - let _subscriber = tracing_subscriber::registry() - .with(trace_layer.with_filter(LevelFilter::TRACE)) - .with(debug_layer.with_filter(LevelFilter::DEBUG)) - .with(info_layer.with_filter(LevelFilter::INFO)) - .set_default(); - - tracing::trace_span!("hello trace"); - tracing::debug_span!("hello debug"); - tracing::info_span!("hello info"); - - trace_handle.assert_finished(); - debug_handle.assert_finished(); - info_handle.assert_finished(); -} - -#[test] -fn global_filters_layers_still_work() { - let (expect, handle) = layer::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() - .run_with_handle(); - - let _subscriber = tracing_subscriber::registry() - .with(expect) - .with(LevelFilter::INFO) - .set_default(); - - tracing::trace!("hello trace"); - tracing::debug!("hello debug"); - tracing::info!("hello info"); - tracing::warn!("hello warn"); - tracing::error!("hello error"); - - handle.assert_finished(); -} - -#[test] -fn global_filter_interests_are_cached() { - let (expect, handle) = layer::mock() - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() - .run_with_handle(); - - let _subscriber = tracing_subscriber::registry() - .with(expect.with_filter(filter::filter_fn(|meta| { - assert!( - meta.level() <= &Level::INFO, - "enabled should not be called for callsites disabled by the global filter" - ); - meta.level() <= &Level::WARN - }))) - .with(LevelFilter::INFO) - .set_default(); - - tracing::trace!("hello trace"); - tracing::debug!("hello debug"); - tracing::info!("hello info"); - tracing::warn!("hello warn"); - tracing::error!("hello error"); - - handle.assert_finished(); -} - -#[test] -fn global_filters_affect_layer_filters() { - let (expect, handle) = layer::named("debug") - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() - .run_with_handle(); - - let _subscriber = tracing_subscriber::registry() - .with(expect.with_filter(LevelFilter::DEBUG)) - .with(LevelFilter::INFO) - .set_default(); - - tracing::trace!("hello trace"); - tracing::debug!("hello debug"); - tracing::info!("hello info"); - tracing::warn!("hello warn"); - tracing::error!("hello error"); - - handle.assert_finished(); -} - -#[test] -fn filter_fn() { - let (all, all_handle) = layer::named("all_targets") - .event(event::msg("hello foo")) - .event(event::msg("hello bar")) - .done() - .run_with_handle(); - - let (foo, foo_handle) = layer::named("foo_target") - .event(event::msg("hello foo")) - .done() - .run_with_handle(); - - let (bar, bar_handle) = layer::named("bar_target") - .event(event::msg("hello bar")) - .done() - .run_with_handle(); - - let _subscriber = tracing_subscriber::registry() - .with(all) - .with(foo.with_filter(filter::filter_fn(|meta| meta.target().starts_with("foo")))) - .with(bar.with_filter(filter::filter_fn(|meta| meta.target().starts_with("bar")))) - .set_default(); - - tracing::trace!(target: "foo", "hello foo"); - tracing::trace!(target: "bar", "hello bar"); - - foo_handle.assert_finished(); - bar_handle.assert_finished(); - all_handle.assert_finished(); -} diff --git a/vendor/tracing-subscriber/tests/layer_filters/targets.rs b/vendor/tracing-subscriber/tests/layer_filters/targets.rs deleted file mode 100644 index c8133044b..000000000 --- a/vendor/tracing-subscriber/tests/layer_filters/targets.rs +++ /dev/null @@ -1,59 +0,0 @@ -use super::*; -use tracing_subscriber::{ - filter::{filter_fn, Targets}, - prelude::*, -}; - -#[test] -#[cfg_attr(not(feature = "tracing-log"), ignore)] -fn log_events() { - // Reproduces https://github.com/tokio-rs/tracing/issues/1563 - mod inner { - pub(super) const MODULE_PATH: &str = module_path!(); - - #[tracing::instrument] - pub(super) fn logs() { - log::debug!("inner"); - } - } - - let filter = Targets::new() - .with_default(LevelFilter::DEBUG) - .with_target(inner::MODULE_PATH, LevelFilter::WARN); - - let layer = - tracing_subscriber::layer::Identity::new().with_filter(filter_fn(move |_meta| true)); - - let _guard = tracing_subscriber::registry() - .with(filter) - .with(layer) - .set_default(); - - inner::logs(); -} - -#[test] -fn inner_layer_short_circuits() { - // This test ensures that when a global filter short-circuits `Interest` - // evaluation, we aren't left with a "dirty" per-layer filter state. - - let (layer, handle) = layer::mock() - .event(event::msg("hello world")) - .done() - .run_with_handle(); - - let filter = Targets::new().with_target("magic_target", LevelFilter::DEBUG); - - let _guard = tracing_subscriber::registry() - // Note: we don't just use a `LevelFilter` for the global filter here, - // because it will just return a max level filter, and the chain of - // `register_callsite` calls that would trigger the bug never happens... - .with(filter::filter_fn(|meta| meta.level() <= &Level::INFO)) - .with(layer.with_filter(filter)) - .set_default(); - - tracing::debug!("skip me please!"); - tracing::info!(target: "magic_target", "hello world"); - - handle.assert_finished(); -} diff --git a/vendor/tracing-subscriber/tests/layer_filters/trees.rs b/vendor/tracing-subscriber/tests/layer_filters/trees.rs deleted file mode 100644 index 18cdd8ccc..000000000 --- a/vendor/tracing-subscriber/tests/layer_filters/trees.rs +++ /dev/null @@ -1,146 +0,0 @@ -use super::*; - -#[test] -fn basic_trees() { - let (with_target, with_target_handle) = layer::named("info_with_target") - .event(event::mock().at_level(Level::INFO).with_target("my_target")) - .done() - .run_with_handle(); - - let (info, info_handle) = layer::named("info") - .event( - event::mock() - .at_level(Level::INFO) - .with_target(module_path!()), - ) - .event(event::mock().at_level(Level::INFO).with_target("my_target")) - .done() - .run_with_handle(); - - let (all, all_handle) = layer::named("all") - .event( - event::mock() - .at_level(Level::INFO) - .with_target(module_path!()), - ) - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::INFO).with_target("my_target")) - .event( - event::mock() - .at_level(Level::TRACE) - .with_target("my_target"), - ) - .done() - .run_with_handle(); - - let info_tree = info - .and_then( - with_target.with_filter(filter::filter_fn(|meta| dbg!(meta.target()) == "my_target")), - ) - .with_filter(LevelFilter::INFO); - - let subscriber = tracing_subscriber::registry().with(info_tree).with(all); - let _guard = dbg!(subscriber).set_default(); - - tracing::info!("hello world"); - tracing::trace!("hello trace"); - tracing::info!(target: "my_target", "hi to my target"); - tracing::trace!(target: "my_target", "hi to my target at trace"); - - all_handle.assert_finished(); - info_handle.assert_finished(); - with_target_handle.assert_finished(); -} - -#[test] -fn filter_span_scopes() { - fn target_layer(target: &'static str) -> (ExpectLayer, subscriber::MockHandle) { - layer::named(format!("target_{}", target)) - .enter(span::mock().with_target(target).at_level(Level::INFO)) - .event( - event::msg("hello world") - .in_scope(vec![span::mock().with_target(target).at_level(Level::INFO)]), - ) - .exit(span::mock().with_target(target).at_level(Level::INFO)) - .done() - .run_with_handle() - } - - let (a_layer, a_handle) = target_layer("a"); - let (b_layer, b_handle) = target_layer("b"); - let (info_layer, info_handle) = layer::named("info") - .enter(span::mock().with_target("b").at_level(Level::INFO)) - .enter(span::mock().with_target("a").at_level(Level::INFO)) - .event(event::msg("hello world").in_scope(vec![ - span::mock().with_target("a").at_level(Level::INFO), - span::mock().with_target("b").at_level(Level::INFO), - ])) - .exit(span::mock().with_target("a").at_level(Level::INFO)) - .exit(span::mock().with_target("b").at_level(Level::INFO)) - .done() - .run_with_handle(); - - let full_scope = vec![ - span::mock().with_target("b").at_level(Level::TRACE), - span::mock().with_target("a").at_level(Level::INFO), - span::mock().with_target("b").at_level(Level::INFO), - span::mock().with_target("a").at_level(Level::TRACE), - ]; - let (all_layer, all_handle) = layer::named("all") - .enter(span::mock().with_target("a").at_level(Level::TRACE)) - .enter(span::mock().with_target("b").at_level(Level::INFO)) - .enter(span::mock().with_target("a").at_level(Level::INFO)) - .enter(span::mock().with_target("b").at_level(Level::TRACE)) - .event(event::msg("hello world").in_scope(full_scope.clone())) - .event( - event::msg("hello to my target") - .with_target("a") - .in_scope(full_scope.clone()), - ) - .event( - event::msg("hello to my target") - .with_target("b") - .in_scope(full_scope), - ) - .exit(span::mock().with_target("b").at_level(Level::TRACE)) - .exit(span::mock().with_target("a").at_level(Level::INFO)) - .exit(span::mock().with_target("b").at_level(Level::INFO)) - .exit(span::mock().with_target("a").at_level(Level::TRACE)) - .done() - .run_with_handle(); - - let a_layer = a_layer.with_filter(filter::filter_fn(|meta| { - let target = meta.target(); - target == "a" || target == module_path!() - })); - - let b_layer = b_layer.with_filter(filter::filter_fn(|meta| { - let target = meta.target(); - target == "b" || target == module_path!() - })); - - let info_tree = info_layer - .and_then(a_layer) - .and_then(b_layer) - .with_filter(LevelFilter::INFO); - - let subscriber = tracing_subscriber::registry() - .with(info_tree) - .with(all_layer); - let _guard = dbg!(subscriber).set_default(); - - { - let _a1 = tracing::trace_span!(target: "a", "a/trace").entered(); - let _b1 = tracing::info_span!(target: "b", "b/info").entered(); - let _a2 = tracing::info_span!(target: "a", "a/info").entered(); - let _b2 = tracing::trace_span!(target: "b", "b/trace").entered(); - tracing::info!("hello world"); - tracing::debug!(target: "a", "hello to my target"); - tracing::debug!(target: "b", "hello to my target"); - } - - all_handle.assert_finished(); - info_handle.assert_finished(); - a_handle.assert_finished(); - b_handle.assert_finished(); -} diff --git a/vendor/tracing-subscriber/tests/layer_filters/vec.rs b/vendor/tracing-subscriber/tests/layer_filters/vec.rs deleted file mode 100644 index 87244e4ab..000000000 --- a/vendor/tracing-subscriber/tests/layer_filters/vec.rs +++ /dev/null @@ -1,120 +0,0 @@ -use super::*; -use tracing::Subscriber; - -#[test] -fn with_filters_unboxed() { - let (trace_layer, trace_handle) = layer::named("trace") - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - let trace_layer = trace_layer.with_filter(LevelFilter::TRACE); - - let (debug_layer, debug_handle) = layer::named("debug") - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - let debug_layer = debug_layer.with_filter(LevelFilter::DEBUG); - - let (info_layer, info_handle) = layer::named("info") - .event(event::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - let info_layer = info_layer.with_filter(LevelFilter::INFO); - - let _subscriber = tracing_subscriber::registry() - .with(vec![trace_layer, debug_layer, info_layer]) - .set_default(); - - tracing::trace!("hello trace"); - tracing::debug!("hello debug"); - tracing::info!("hello info"); - - trace_handle.assert_finished(); - debug_handle.assert_finished(); - info_handle.assert_finished(); -} - -#[test] -fn with_filters_boxed() { - let (unfiltered_layer, unfiltered_handle) = layer::named("unfiltered") - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - let unfiltered_layer = unfiltered_layer.boxed(); - - let (debug_layer, debug_handle) = layer::named("debug") - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - let debug_layer = debug_layer.with_filter(LevelFilter::DEBUG).boxed(); - - let (target_layer, target_handle) = layer::named("target") - .event(event::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - let target_layer = target_layer - .with_filter(filter::filter_fn(|meta| meta.target() == "my_target")) - .boxed(); - - let _subscriber = tracing_subscriber::registry() - .with(vec![unfiltered_layer, debug_layer, target_layer]) - .set_default(); - - tracing::trace!("hello trace"); - tracing::debug!("hello debug"); - tracing::info!(target: "my_target", "hello my target"); - - unfiltered_handle.assert_finished(); - debug_handle.assert_finished(); - target_handle.assert_finished(); -} - -#[test] -fn mixed_max_level_hint() { - let unfiltered = layer::named("unfiltered").run().boxed(); - let info = layer::named("info") - .run() - .with_filter(LevelFilter::INFO) - .boxed(); - let debug = layer::named("debug") - .run() - .with_filter(LevelFilter::DEBUG) - .boxed(); - - let subscriber = tracing_subscriber::registry().with(vec![unfiltered, info, debug]); - - assert_eq!(subscriber.max_level_hint(), None); -} - -#[test] -fn all_filtered_max_level_hint() { - let warn = layer::named("warn") - .run() - .with_filter(LevelFilter::WARN) - .boxed(); - let info = layer::named("info") - .run() - .with_filter(LevelFilter::INFO) - .boxed(); - let debug = layer::named("debug") - .run() - .with_filter(LevelFilter::DEBUG) - .boxed(); - - let subscriber = tracing_subscriber::registry().with(vec![warn, info, debug]); - - assert_eq!(subscriber.max_level_hint(), Some(LevelFilter::DEBUG)); -} - -#[test] -fn empty_vec() { - // Just a None means everything is off - let subscriber = tracing_subscriber::registry().with(Vec::<ExpectLayer>::new()); - assert_eq!(subscriber.max_level_hint(), Some(LevelFilter::OFF)); -} |