From 2e208ad1ef92a94a496502b464ede4600828e905 Mon Sep 17 00:00:00 2001 From: Hayden Stainsby Date: Thu, 10 Nov 2022 22:39:40 +0100 Subject: [PATCH] mock: differentiate between mocks and expectations (#2373) The `tracing-mock` crate provides a mock collector (and a subscriber for use by the tests in the `tracing-subscriber` crate) which is able to make assertions about what diagnostics are emitted. These assertions are defined by structs that match on events, span, and their fields and metadata. The structs that matched these objects have been called, up until now, mocks, however this terminology may be misleading, as the created objects don't mock anything. There were two different names for similar functionality with `only()` and `done()` on fields and collectors/subscribers respectively. Using a single name for these may make it easier to onboard onto `tracing-mock`. To reduce confusion, these structs have been split into two categories: mocks and expectations. Additionally, the `done()` function on the `Collector` and `Subscriber` mocks has been replaced with `only()`. This matches the similar function for `ExpectedField`, and may be more intuitive. The mocks replace some component in the tracing ecosystem when a library is under test. The expectations define the assertions we wish to make about traces received by the mocks. Mocks (per module): * collector - `MockCollector`, no change * subscriber - `MockSubscriber`, renamed from `ExpectSubscriber` Expectations (per module): * event - `ExpectedEvent`, renamed from `MockEvent` * span - `ExpectedSpan`, renamed from `MockSpan` * field - `ExpectedField` and `ExpectedFields`, renamed from `MockField` and `Expected`. Also `ExpectedValue` renamed from `MockValue`. * metadata - `ExpectedMetadata`, renamed from `Expected` Refs: #539 --- tracing-attributes/tests/err.rs | 21 +++++ tracing-attributes/tests/levels.rs | 32 +++---- tracing-attributes/tests/ret.rs | 24 ++--- tracing-mock/src/expectation.rs | 22 ++--- tracing-mock/src/layer.rs | 69 ++++++++------ ...d_layer_filters_dont_break_other_layers.rs | 20 ++-- .../tests/env_filter/per_layer.rs | 74 +++++++-------- ...d_layer_filters_dont_break_other_layers.rs | 26 +++--- .../layer_filter_interests_are_cached.rs | 6 +- .../tests/layer_filters/boxed.rs | 2 +- .../tests/layer_filters/combinators.rs | 2 +- .../tests/layer_filters/filter_scopes.rs | 92 +++++++++---------- .../tests/layer_filters/main.rs | 72 +++++++-------- .../tests/layer_filters/per_event.rs | 8 +- .../tests/layer_filters/targets.rs | 2 +- .../tests/layer_filters/trees.rs | 85 +++++++++-------- tracing-subscriber/tests/layer_filters/vec.rs | 42 ++++----- .../multiple_layer_filter_interests_cached.rs | 24 ++--- ...d_layer_filters_dont_break_other_layers.rs | 20 ++-- tracing/tests/event.rs | 10 +- tracing/tests/no_subscriber.rs | 11 ++- tracing/tests/scoped_clobbers_default.rs | 4 +- tracing/tests/span.rs | 22 ++--- tracing/tests/subscriber.rs | 28 +++--- 24 files changed, 386 insertions(+), 332 deletions(-) diff --git a/tracing-attributes/tests/err.rs b/tracing-attributes/tests/err.rs index d5d508f545..8cf5d36103 100644 --- a/tracing-attributes/tests/err.rs +++ b/tracing-attributes/tests/err.rs @@ -56,6 +56,27 @@ fn test_early_return() { handle.assert_finished(); } +#[instrument(err)] +fn err_early_return() -> Result { + u8::try_from(1234)?; + Ok(5) +} + +#[test] +fn test_early_return() { + let span = span::expect().named("err_early_return"); + let (subscriber, handle) = subscriber::mock() + .new_span(span.clone()) + .enter(span.clone()) + .event(event::expect().at_level(Level::ERROR)) + .exit(span.clone()) + .drop_span(span) + .only() + .run_with_handle(); + with_default(subscriber, || err_early_return().ok()); + handle.assert_finished(); +} + #[instrument(err)] async fn err_async(polls: usize) -> Result { let future = PollN::new_ok(polls); diff --git a/tracing-attributes/tests/levels.rs b/tracing-attributes/tests/levels.rs index 586f537508..5e9e14d528 100644 --- a/tracing-attributes/tests/levels.rs +++ b/tracing-attributes/tests/levels.rs @@ -158,22 +158,22 @@ fn enum_levels() { #[instrument(level = Level::ERROR)] fn error() {} let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("trace").at_level(Level::TRACE)) - .enter(span::mock().named("trace").at_level(Level::TRACE)) - .exit(span::mock().named("trace").at_level(Level::TRACE)) - .new_span(span::mock().named("debug").at_level(Level::DEBUG)) - .enter(span::mock().named("debug").at_level(Level::DEBUG)) - .exit(span::mock().named("debug").at_level(Level::DEBUG)) - .new_span(span::mock().named("info").at_level(Level::INFO)) - .enter(span::mock().named("info").at_level(Level::INFO)) - .exit(span::mock().named("info").at_level(Level::INFO)) - .new_span(span::mock().named("warn").at_level(Level::WARN)) - .enter(span::mock().named("warn").at_level(Level::WARN)) - .exit(span::mock().named("warn").at_level(Level::WARN)) - .new_span(span::mock().named("error").at_level(Level::ERROR)) - .enter(span::mock().named("error").at_level(Level::ERROR)) - .exit(span::mock().named("error").at_level(Level::ERROR)) - .done() + .new_span(span::expect().named("trace").at_level(Level::TRACE)) + .enter(span::expect().named("trace").at_level(Level::TRACE)) + .exit(span::expect().named("trace").at_level(Level::TRACE)) + .new_span(span::expect().named("debug").at_level(Level::DEBUG)) + .enter(span::expect().named("debug").at_level(Level::DEBUG)) + .exit(span::expect().named("debug").at_level(Level::DEBUG)) + .new_span(span::expect().named("info").at_level(Level::INFO)) + .enter(span::expect().named("info").at_level(Level::INFO)) + .exit(span::expect().named("info").at_level(Level::INFO)) + .new_span(span::expect().named("warn").at_level(Level::WARN)) + .enter(span::expect().named("warn").at_level(Level::WARN)) + .exit(span::expect().named("warn").at_level(Level::WARN)) + .new_span(span::expect().named("error").at_level(Level::ERROR)) + .enter(span::expect().named("error").at_level(Level::ERROR)) + .exit(span::expect().named("error").at_level(Level::ERROR)) + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/tracing-attributes/tests/ret.rs b/tracing-attributes/tests/ret.rs index 0a4d7cfdb3..a93c31dc58 100644 --- a/tracing-attributes/tests/ret.rs +++ b/tracing-attributes/tests/ret.rs @@ -69,7 +69,7 @@ fn test_custom_target() { #[test] fn test_custom_target() { let filter: EnvFilter = "my_target=info".parse().expect("filter should parse"); - let span = span::mock() + let span = span::expect() .named("ret_with_target") .with_target("my_target"); @@ -77,14 +77,14 @@ fn test_custom_target() { .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO) .with_target("my_target"), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -342,18 +342,18 @@ fn ret_warn_info() -> i32 { #[test] fn test_warn_info() { - let span = span::mock().named("ret_warn_info").at_level(Level::WARN); + let span = span::expect().named("ret_warn_info").at_level(Level::WARN); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, ret_warn_info); @@ -367,18 +367,18 @@ fn ret_dbg_warn() -> i32 { #[test] fn test_dbg_warn() { - let span = span::mock().named("ret_dbg_warn").at_level(Level::INFO); + let span = span::expect().named("ret_dbg_warn").at_level(Level::INFO); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::WARN), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, ret_dbg_warn); diff --git a/tracing-mock/src/expectation.rs b/tracing-mock/src/expectation.rs index 0328754fc8..cd48728ae7 100644 --- a/tracing-mock/src/expectation.rs +++ b/tracing-mock/src/expectation.rs @@ -1,21 +1,21 @@ use crate::{ - event::MockEvent, - field, - span::{MockSpan, NewSpan}, + event::ExpectedEvent, + field::ExpectedFields, + span::{ExpectedSpan, NewSpan}, }; #[derive(Debug, Eq, PartialEq)] pub(crate) enum Expect { - Event(MockEvent), + Event(ExpectedEvent), FollowsFrom { - consequence: MockSpan, - cause: MockSpan, + consequence: ExpectedSpan, + cause: ExpectedSpan, }, - Enter(MockSpan), - Exit(MockSpan), - CloneSpan(MockSpan), - DropSpan(MockSpan), - Visit(MockSpan, field::Expect), + Enter(ExpectedSpan), + Exit(ExpectedSpan), + CloneSpan(ExpectedSpan), + DropSpan(ExpectedSpan), + Visit(ExpectedSpan, ExpectedFields), NewSpan(NewSpan), Nothing, } diff --git a/tracing-mock/src/layer.rs b/tracing-mock/src/layer.rs index 0a0a02005d..85509ab075 100644 --- a/tracing-mock/src/layer.rs +++ b/tracing-mock/src/layer.rs @@ -1,7 +1,9 @@ +#![allow(missing_docs, dead_code)] use crate::{ - event::MockEvent, + event::ExpectedEvent, expectation::Expect, - span::{MockSpan, NewSpan}, + field::ExpectedFields, + span::{ExpectedSpan, NewSpan}, subscriber::MockHandle, }; use tracing_core::{ @@ -19,7 +21,6 @@ use std::{ sync::{Arc, Mutex}, }; -#[must_use] pub fn mock() -> MockLayerBuilder { MockLayerBuilder { expected: Default::default(), @@ -30,7 +31,6 @@ pub fn mock() -> MockLayerBuilder { } } -#[must_use] pub fn named(name: impl std::fmt::Display) -> MockLayerBuilder { mock().named(name) } @@ -47,6 +47,19 @@ pub struct MockLayer { } impl MockLayerBuilder { + /// Overrides the name printed by the mock layer's debugging output. + /// + /// The debugging output is displayed if the test panics, or if the test is + /// run with `--nocapture`. + /// + /// By default, the mock layer's name is the name of the test + /// (*technically*, the name of the thread where it was created, which is + /// the name of the test unless tests are run with `--test-threads=1`). + /// When a test has only one mock layer, this is sufficient. However, + /// some tests may include multiple layers, in order to test + /// interactions between multiple layers. In that case, it can be + /// helpful to give each layer a separate name to distinguish where the + /// debugging output comes from. pub fn named(mut self, name: impl fmt::Display) -> Self { use std::fmt::Write; if !self.name.is_empty() { @@ -57,31 +70,39 @@ impl MockLayerBuilder { self } - pub fn event(mut self, event: MockEvent) -> Self { + pub fn enter(mut self, span: ExpectedSpan) -> Self { + self.expected.push_back(Expect::Enter(span)); + self + } + + pub fn event(mut self, event: ExpectedEvent) -> Self { self.expected.push_back(Expect::Event(event)); self } - pub fn new_span(mut self, new_span: I) -> Self - where - I: Into, - { - self.expected.push_back(Expect::NewSpan(new_span.into())); + pub fn exit(mut self, span: ExpectedSpan) -> Self { + self.expected.push_back(Expect::Exit(span)); self } - pub fn enter(mut self, span: MockSpan) -> Self { - self.expected.push_back(Expect::Enter(span)); + pub fn only(mut self) -> Self { + self.expected.push_back(Expect::Nothing); self } - pub fn exit(mut self, span: MockSpan) -> Self { - self.expected.push_back(Expect::Exit(span)); + pub fn record(mut self, span: ExpectedSpan, fields: I) -> Self + where + I: Into, + { + self.expected.push_back(Expect::Visit(span, fields.into())); self } - pub fn done(mut self) -> Self { - self.expected.push_back(Expect::Nothing); + pub fn new_span(mut self, new_span: I) -> Self + where + I: Into, + { + self.expected.push_back(Expect::NewSpan(new_span.into())); self } @@ -96,19 +117,19 @@ impl MockLayerBuilder { pub fn run_with_handle(self) -> (MockLayer, MockHandle) { let expected = Arc::new(Mutex::new(self.expected)); let handle = MockHandle::new(expected.clone(), self.name.clone()); - let subscriber = MockLayer { + let layer = MockLayer { expected, name: self.name, current: Mutex::new(Vec::new()), }; - (subscriber, handle) + (layer, handle) } } impl MockLayer { fn check_span_ref<'spans, S>( &self, - expected: &MockSpan, + expected: &ExpectedSpan, actual: &SpanRef<'spans, S>, what_happened: impl fmt::Display, ) where @@ -238,11 +259,7 @@ where } fn on_follows_from(&self, _span: &Id, _follows: &Id, _: Context<'_, C>) { - unimplemented!( - "so far, we don't have any tests that need an `on_follows_from` \ - implementation.\nif you just wrote one that does, feel free to \ - implement it!" - ); + // TODO: it should be possible to expect spans to follow from other spans } fn on_new_span(&self, span: &Attributes<'_>, id: &Id, cx: Context<'_, C>) { @@ -360,13 +377,13 @@ where } fn on_id_change(&self, _old: &Id, _new: &Id, _ctx: Context<'_, C>) { - panic!("well-behaved subscribers should never do this to us, lol"); + panic!("well-behaved Layers should never do this to us, lol"); } } impl fmt::Debug for MockLayer { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let mut s = f.debug_struct("MockLayer"); + let mut s = f.debug_struct("Expectlayer"); s.field("name", &self.name); if let Ok(expected) = self.expected.try_lock() { diff --git a/tracing-subscriber/tests/cached_layer_filters_dont_break_other_layers.rs b/tracing-subscriber/tests/cached_layer_filters_dont_break_other_layers.rs index 5b40b60aa3..478b6e9b20 100644 --- a/tracing-subscriber/tests/cached_layer_filters_dont_break_other_layers.rs +++ b/tracing-subscriber/tests/cached_layer_filters_dont_break_other_layers.rs @@ -107,20 +107,20 @@ fn filter() -> LevelFilter { fn unfiltered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } fn filtered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } diff --git a/tracing-subscriber/tests/env_filter/per_layer.rs b/tracing-subscriber/tests/env_filter/per_layer.rs index 4b143b8bfd..587d34fb77 100644 --- a/tracing-subscriber/tests/env_filter/per_layer.rs +++ b/tracing-subscriber/tests/env_filter/per_layer.rs @@ -8,10 +8,10 @@ use tracing_mock::{event, field, layer, span}; fn level_filter_event() { let filter: EnvFilter = "info".parse().expect("filter should parse"); let (layer, 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() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -34,18 +34,18 @@ fn same_name_spans() { .expect("filter should parse"); let (layer, handle) = layer::mock() .new_span( - span::mock() + span::expect() .named("foo") .at_level(Level::TRACE) - .with_field(field::mock("bar")), + .with_field(field::expect("bar")), ) .new_span( - span::mock() + span::expect() .named("foo") .at_level(Level::TRACE) - .with_field(field::mock("baz")), + .with_field(field::expect("baz")), ) - .done() + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -62,12 +62,12 @@ fn same_name_spans() { fn level_filter_event_with_target() { let filter: EnvFilter = "info,stuff=debug".parse().expect("filter should parse"); let (layer, handle) = layer::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG).with_target("stuff")) - .event(event::mock().at_level(Level::WARN).with_target("stuff")) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::ERROR).with_target("stuff")) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) + .event(event::expect().at_level(Level::WARN).with_target("stuff")) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -96,12 +96,12 @@ fn level_filter_event_with_target_and_span() { let (layer, handle) = layer::mock() .enter(cool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) .exit(cool_span) - .done() + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -129,12 +129,12 @@ fn not_order_dependent() { let filter: EnvFilter = "stuff=debug,info".parse().expect("filter should parse"); let (layer, finished) = layer::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG).with_target("stuff")) - .event(event::mock().at_level(Level::WARN).with_target("stuff")) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::ERROR).with_target("stuff")) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) + .event(event::expect().at_level(Level::WARN).with_target("stuff")) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -164,9 +164,9 @@ fn add_directive_enables_event() { filter = filter.add_directive("hello=trace".parse().expect("directive should parse")); let (layer, finished) = layer::mock() - .event(event::mock().at_level(Level::INFO).with_target("hello")) - .event(event::mock().at_level(Level::TRACE).with_target("hello")) - .done() + .event(event::expect().at_level(Level::INFO).with_target("hello")) + .event(event::expect().at_level(Level::TRACE).with_target("hello")) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -187,21 +187,21 @@ fn span_name_filter_is_dynamic() { let cool_span = span::named("cool_span"); let uncool_span = span::named("uncool_span"); let (layer, finished) = layer::mock() - .event(event::mock().at_level(Level::INFO)) + .event(event::expect().at_level(Level::INFO)) .enter(cool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) .enter(uncool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::WARN) .in_scope(vec![uncool_span.clone()]), ) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![uncool_span.clone()]), ) @@ -209,17 +209,17 @@ fn span_name_filter_is_dynamic() { .exit(cool_span) .enter(uncool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::WARN) .in_scope(vec![uncool_span.clone()]), ) .event( - event::mock() + event::expect() .at_level(Level::ERROR) .in_scope(vec![uncool_span.clone()]), ) .exit(uncool_span) - .done() + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -260,12 +260,12 @@ fn multiple_dynamic_filters() { let (layer, handle) = layer::named("layer1") .enter(span.clone()) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![span.clone()]), ) .exit(span) - .done() + .only() .run_with_handle(); (layer.with_filter(filter), handle) }; @@ -276,12 +276,12 @@ fn multiple_dynamic_filters() { let (layer, handle) = layer::named("layer2") .enter(span.clone()) .event( - event::mock() + event::expect() .at_level(Level::INFO) .in_scope(vec![span.clone()]), ) .exit(span) - .done() + .only() .run_with_handle(); (layer.with_filter(filter), handle) }; diff --git a/tracing-subscriber/tests/hinted_layer_filters_dont_break_other_layers.rs b/tracing-subscriber/tests/hinted_layer_filters_dont_break_other_layers.rs index 4e5ee4e050..bbb68bd87a 100644 --- a/tracing-subscriber/tests/hinted_layer_filters_dont_break_other_layers.rs +++ b/tracing-subscriber/tests/hinted_layer_filters_dont_break_other_layers.rs @@ -1,9 +1,9 @@ #![cfg(feature = "registry")] use tracing::{Level, Metadata, Subscriber}; use tracing_mock::{ - event, - layer::{self, MockLayer}, - subscriber, + event, layer, + layer::MockLayer, + subscriber::{self}, }; use tracing_subscriber::{filter::DynFilterFn, layer::Context, prelude::*}; @@ -115,20 +115,20 @@ fn filter() -> DynFilterFn { fn unfiltered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } fn filtered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } diff --git a/tracing-subscriber/tests/layer_filter_interests_are_cached.rs b/tracing-subscriber/tests/layer_filter_interests_are_cached.rs index 67e8ba763c..c5f86c3cc9 100644 --- a/tracing-subscriber/tests/layer_filter_interests_are_cached.rs +++ b/tracing-subscriber/tests/layer_filter_interests_are_cached.rs @@ -21,9 +21,9 @@ fn layer_filter_interests_are_cached() { }); let (expect, handle) = layer::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let subscriber = tracing_subscriber::registry().with(expect.with_filter(filter)); diff --git a/tracing-subscriber/tests/layer_filters/boxed.rs b/tracing-subscriber/tests/layer_filters/boxed.rs index b02331a6c3..96566a5441 100644 --- a/tracing-subscriber/tests/layer_filters/boxed.rs +++ b/tracing-subscriber/tests/layer_filters/boxed.rs @@ -3,7 +3,7 @@ use tracing_mock::layer::MockLayer; use tracing_subscriber::{filter, prelude::*, Layer}; fn layer() -> (MockLayer, subscriber::MockHandle) { - layer::mock().done().run_with_handle() + layer::mock().only().run_with_handle() } fn filter() -> filter::DynFilterFn { diff --git a/tracing-subscriber/tests/layer_filters/combinators.rs b/tracing-subscriber/tests/layer_filters/combinators.rs index 6052a2d00c..c5ea3b5151 100644 --- a/tracing-subscriber/tests/layer_filters/combinators.rs +++ b/tracing-subscriber/tests/layer_filters/combinators.rs @@ -12,7 +12,7 @@ fn and() { .at_level(tracing::Level::INFO) .with_target("interesting_target"), ) - .done() + .only() .run_with_handle(); // Enables spans and events with targets starting with `interesting_target`: diff --git a/tracing-subscriber/tests/layer_filters/filter_scopes.rs b/tracing-subscriber/tests/layer_filters/filter_scopes.rs index d5608a8965..b3957e9a30 100644 --- a/tracing-subscriber/tests/layer_filters/filter_scopes.rs +++ b/tracing-subscriber/tests/layer_filters/filter_scopes.rs @@ -4,46 +4,46 @@ use tracing_mock::layer::MockLayer; #[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)) + .enter(span::expect().at_level(Level::DEBUG)) + .enter(span::expect().at_level(Level::INFO)) + .enter(span::expect().at_level(Level::WARN)) + .enter(span::expect().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), + span::expect().at_level(Level::ERROR), + span::expect().at_level(Level::WARN), + span::expect().at_level(Level::INFO), + span::expect().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() + .exit(span::expect().at_level(Level::ERROR)) + .exit(span::expect().at_level(Level::WARN)) + .exit(span::expect().at_level(Level::INFO)) + .exit(span::expect().at_level(Level::DEBUG)) + .only() .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)) + .enter(span::expect().at_level(Level::INFO)) + .enter(span::expect().at_level(Level::WARN)) + .enter(span::expect().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::expect().at_level(Level::ERROR), + span::expect().at_level(Level::WARN), + span::expect().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() + .exit(span::expect().at_level(Level::ERROR)) + .exit(span::expect().at_level(Level::WARN)) + .exit(span::expect().at_level(Level::INFO)) + .only() .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)) + .enter(span::expect().at_level(Level::WARN)) + .enter(span::expect().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::expect().at_level(Level::ERROR), + span::expect().at_level(Level::WARN), ])) - .exit(span::mock().at_level(Level::ERROR)) - .exit(span::mock().at_level(Level::WARN)) - .done() + .exit(span::expect().at_level(Level::ERROR)) + .exit(span::expect().at_level(Level::WARN)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -70,38 +70,38 @@ fn filters_span_scopes() { fn filters_interleaved_span_scopes() { fn target_layer(target: &'static str) -> (MockLayer, subscriber::MockHandle) { layer::named(format!("target_{}", target)) - .enter(span::mock().with_target(target)) - .enter(span::mock().with_target(target)) + .enter(span::expect().with_target(target)) + .enter(span::expect().with_target(target)) .event(event::msg("hello world").in_scope(vec![ - span::mock().with_target(target), - span::mock().with_target(target), + span::expect().with_target(target), + span::expect().with_target(target), ])) .event( event::msg("hello to my target") .in_scope(vec![ - span::mock().with_target(target), - span::mock().with_target(target), + span::expect().with_target(target), + span::expect().with_target(target), ]) .with_target(target), ) - .exit(span::mock().with_target(target)) - .exit(span::mock().with_target(target)) - .done() + .exit(span::expect().with_target(target)) + .exit(span::expect().with_target(target)) + .only() .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")) + .enter(span::expect().with_target("b")) + .enter(span::expect().with_target("a")) .event(event::msg("hello world").in_scope(vec![ - span::mock().with_target("a"), - span::mock().with_target("b"), + span::expect().with_target("a"), + span::expect().with_target("b"), ])) - .exit(span::mock().with_target("a")) - .exit(span::mock().with_target("b")) - .done() + .exit(span::expect().with_target("a")) + .exit(span::expect().with_target("b")) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() diff --git a/tracing-subscriber/tests/layer_filters/main.rs b/tracing-subscriber/tests/layer_filters/main.rs index fed74038c7..5b8812f713 100644 --- a/tracing-subscriber/tests/layer_filters/main.rs +++ b/tracing-subscriber/tests/layer_filters/main.rs @@ -12,23 +12,23 @@ use tracing_mock::{event, layer, span, subscriber}; use tracing_subscriber::{filter, prelude::*, Layer}; #[test] -fn basic_layer_filters() { +fn basic_subscriber_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() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .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() + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let (info_layer, info_handle) = layer::named("info") - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -47,23 +47,23 @@ fn basic_layer_filters() { } #[test] -fn basic_layer_filters_spans() { +fn basic_subscriber_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() + .new_span(span::expect().at_level(Level::TRACE)) + .new_span(span::expect().at_level(Level::DEBUG)) + .new_span(span::expect().at_level(Level::INFO)) + .only() .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() + .new_span(span::expect().at_level(Level::DEBUG)) + .new_span(span::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let (info_layer, info_handle) = layer::named("info") - .new_span(span::mock().at_level(Level::INFO)) - .done() + .new_span(span::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -82,12 +82,12 @@ fn basic_layer_filters_spans() { } #[test] -fn global_filters_layers_still_work() { +fn global_filters_subscribers_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() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -107,9 +107,9 @@ fn global_filters_layers_still_work() { #[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() + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -133,12 +133,12 @@ fn global_filter_interests_are_cached() { } #[test] -fn global_filters_affect_layer_filters() { +fn global_filters_affect_subscriber_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() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -160,17 +160,17 @@ fn filter_fn() { let (all, all_handle) = layer::named("all_targets") .event(event::msg("hello foo")) .event(event::msg("hello bar")) - .done() + .only() .run_with_handle(); let (foo, foo_handle) = layer::named("foo_target") .event(event::msg("hello foo")) - .done() + .only() .run_with_handle(); let (bar, bar_handle) = layer::named("bar_target") .event(event::msg("hello bar")) - .done() + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() diff --git a/tracing-subscriber/tests/layer_filters/per_event.rs b/tracing-subscriber/tests/layer_filters/per_event.rs index 3a28d94f08..9eb9855426 100644 --- a/tracing-subscriber/tests/layer_filters/per_event.rs +++ b/tracing-subscriber/tests/layer_filters/per_event.rs @@ -40,11 +40,11 @@ impl Filter for FilterEvent { } #[test] -fn per_subscriber_event_field_filtering() { +fn per_layer_event_field_filtering() { let (expect, handle) = layer::mock() - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() diff --git a/tracing-subscriber/tests/layer_filters/targets.rs b/tracing-subscriber/tests/layer_filters/targets.rs index c8133044b1..56f6448822 100644 --- a/tracing-subscriber/tests/layer_filters/targets.rs +++ b/tracing-subscriber/tests/layer_filters/targets.rs @@ -39,7 +39,7 @@ fn inner_layer_short_circuits() { let (layer, handle) = layer::mock() .event(event::msg("hello world")) - .done() + .only() .run_with_handle(); let filter = Targets::new().with_target("magic_target", LevelFilter::DEBUG); diff --git a/tracing-subscriber/tests/layer_filters/trees.rs b/tracing-subscriber/tests/layer_filters/trees.rs index 02830122ca..1418fc40fa 100644 --- a/tracing-subscriber/tests/layer_filters/trees.rs +++ b/tracing-subscriber/tests/layer_filters/trees.rs @@ -4,34 +4,46 @@ use tracing_mock::layer::MockLayer; #[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() + .event( + event::expect() + .at_level(Level::INFO) + .with_target("my_target"), + ) + .only() .run_with_handle(); let (info, info_handle) = layer::named("info") .event( - event::mock() + event::expect() .at_level(Level::INFO) .with_target(module_path!()), ) - .event(event::mock().at_level(Level::INFO).with_target("my_target")) - .done() + .event( + event::expect() + .at_level(Level::INFO) + .with_target("my_target"), + ) + .only() .run_with_handle(); let (all, all_handle) = layer::named("all") .event( - event::mock() + event::expect() .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::expect().at_level(Level::TRACE)) + .event( + event::expect() + .at_level(Level::INFO) + .with_target("my_target"), + ) .event( - event::mock() + event::expect() .at_level(Level::TRACE) .with_target("my_target"), ) - .done() + .only() .run_with_handle(); let info_tree = info @@ -57,41 +69,40 @@ fn basic_trees() { fn filter_span_scopes() { fn target_layer(target: &'static str) -> (MockLayer, 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() + .enter(span::expect().with_target(target).at_level(Level::INFO)) + .event(event::msg("hello world").in_scope(vec![ + span::expect().with_target(target).at_level(Level::INFO), + ])) + .exit(span::expect().with_target(target).at_level(Level::INFO)) + .only() .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)) + .enter(span::expect().with_target("b").at_level(Level::INFO)) + .enter(span::expect().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), + span::expect().with_target("a").at_level(Level::INFO), + span::expect().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() + .exit(span::expect().with_target("a").at_level(Level::INFO)) + .exit(span::expect().with_target("b").at_level(Level::INFO)) + .only() .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), + span::expect().with_target("b").at_level(Level::TRACE), + span::expect().with_target("a").at_level(Level::INFO), + span::expect().with_target("b").at_level(Level::INFO), + span::expect().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)) + .enter(span::expect().with_target("a").at_level(Level::TRACE)) + .enter(span::expect().with_target("b").at_level(Level::INFO)) + .enter(span::expect().with_target("a").at_level(Level::INFO)) + .enter(span::expect().with_target("b").at_level(Level::TRACE)) .event(event::msg("hello world").in_scope(full_scope.clone())) .event( event::msg("hello to my target") @@ -103,11 +114,11 @@ fn filter_span_scopes() { .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() + .exit(span::expect().with_target("b").at_level(Level::TRACE)) + .exit(span::expect().with_target("a").at_level(Level::INFO)) + .exit(span::expect().with_target("b").at_level(Level::INFO)) + .exit(span::expect().with_target("a").at_level(Level::TRACE)) + .only() .run_with_handle(); let a_layer = a_layer.with_filter(filter::filter_fn(|meta| { diff --git a/tracing-subscriber/tests/layer_filters/vec.rs b/tracing-subscriber/tests/layer_filters/vec.rs index dbe3674785..884ec60a95 100644 --- a/tracing-subscriber/tests/layer_filters/vec.rs +++ b/tracing-subscriber/tests/layer_filters/vec.rs @@ -1,27 +1,27 @@ use super::*; use tracing::Subscriber; -use tracing_mock::layer::{self, MockLayer}; +use tracing_mock::layer::MockLayer; #[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() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .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() + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .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() + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let info_layer = info_layer.with_filter(LevelFilter::INFO); @@ -41,23 +41,23 @@ fn with_filters_unboxed() { #[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() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .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() + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .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() + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let target_layer = target_layer .with_filter(filter::filter_fn(|meta| meta.target() == "my_target")) @@ -116,6 +116,6 @@ fn all_filtered_max_level_hint() { #[test] fn empty_vec() { // Just a None means everything is off - let subscriber = tracing_subscriber::registry().with(Vec::::new()); - assert_eq!(subscriber.max_level_hint(), Some(LevelFilter::OFF)); + let collector = tracing_subscriber::registry().with(Vec::::new()); + assert_eq!(collector.max_level_hint(), Some(LevelFilter::OFF)); } diff --git a/tracing-subscriber/tests/multiple_layer_filter_interests_cached.rs b/tracing-subscriber/tests/multiple_layer_filter_interests_cached.rs index 13e1a94a3e..6f9ee0c310 100644 --- a/tracing-subscriber/tests/multiple_layer_filter_interests_cached.rs +++ b/tracing-subscriber/tests/multiple_layer_filter_interests_cached.rs @@ -23,13 +23,13 @@ fn multiple_layer_filter_interests_are_cached() { let seen_info = seen_info2; let (info_layer, info_handle) = layer::named("info") - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let info_layer = info_layer.with_filter(filter); @@ -47,11 +47,11 @@ fn multiple_layer_filter_interests_are_cached() { let seen_warn = seen_warn2; let (warn_layer, warn_handle) = layer::named("warn") - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let warn_layer = warn_layer.with_filter(filter); diff --git a/tracing-subscriber/tests/unhinted_layer_filters_dont_break_other_layers.rs b/tracing-subscriber/tests/unhinted_layer_filters_dont_break_other_layers.rs index d8b38345f9..9078b66b35 100644 --- a/tracing-subscriber/tests/unhinted_layer_filters_dont_break_other_layers.rs +++ b/tracing-subscriber/tests/unhinted_layer_filters_dont_break_other_layers.rs @@ -107,20 +107,20 @@ fn filter() -> DynFilterFn { fn unfiltered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } fn filtered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } diff --git a/tracing/tests/event.rs b/tracing/tests/event.rs index 347dba72bd..3a85d1b4f0 100644 --- a/tracing/tests/event.rs +++ b/tracing/tests/event.rs @@ -502,11 +502,15 @@ fn constant_field_name() { #[test] fn string_field() { let (subscriber, handle) = subscriber::mock() - .event(event::mock().with_fields(field::mock("my_string").with_value(&"hello").only())) + .event(event::expect().with_fields(field::expect("my_string").with_value(&"hello").only())) .event( - event::mock().with_fields(field::mock("my_string").with_value(&"hello world!").only()), + event::expect().with_fields( + field::expect("my_string") + .with_value(&"hello world!") + .only(), + ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { let mut my_string = String::from("hello"); diff --git a/tracing/tests/no_subscriber.rs b/tracing/tests/no_subscriber.rs index 5f927c1dee..77e2c106c1 100644 --- a/tracing/tests/no_subscriber.rs +++ b/tracing/tests/no_subscriber.rs @@ -1,14 +1,15 @@ #![cfg(feature = "std")] -use tracing::subscriber::{self, NoSubscriber}; +use tracing_mock::subscriber; #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] -fn no_subscriber_disables_global() { +fn no_collector_disables_global() { // Reproduces https://github.com/tokio-rs/tracing/issues/1999 - let (subscriber, handle) = tracing_mock::subscriber::mock().done().run_with_handle(); - subscriber::set_global_default(subscriber).expect("setting global default must succeed"); - subscriber::with_default(NoSubscriber::default(), || { + let (subscriber, handle) = subscriber::mock().only().run_with_handle(); + tracing::subscriber::set_global_default(subscriber) + .expect("setting global default must succeed"); + tracing::subscriber::with_default(tracing::subscriber::NoSubscriber::default(), || { tracing::info!("this should not be recorded"); }); handle.assert_finished(); diff --git a/tracing/tests/scoped_clobbers_default.rs b/tracing/tests/scoped_clobbers_default.rs index 362d34a82c..dfd6fc9de2 100644 --- a/tracing/tests/scoped_clobbers_default.rs +++ b/tracing/tests/scoped_clobbers_default.rs @@ -8,12 +8,12 @@ fn scoped_clobbers_global() { let (scoped, scoped_handle) = subscriber::mock() .event(event::msg("before global")) .event(event::msg("before drop")) - .done() + .only() .run_with_handle(); let (global, global_handle) = subscriber::mock() .event(event::msg("after drop")) - .done() + .only() .run_with_handle(); // Set a scoped default subscriber, returning a guard. diff --git a/tracing/tests/span.rs b/tracing/tests/span.rs index af43ef86ca..b1d6d63bfa 100644 --- a/tracing/tests/span.rs +++ b/tracing/tests/span.rs @@ -341,11 +341,11 @@ fn entered_api() { #[test] fn entered() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .event(event::mock()) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect()) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { let _span = tracing::span!(Level::TRACE, "foo").entered(); @@ -359,11 +359,11 @@ fn entered() { #[test] fn entered_api() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .event(event::mock()) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect()) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { let span = tracing::span!(Level::TRACE, "foo").entered(); @@ -528,7 +528,7 @@ fn float_values() { fn add_field_after_new_span() { let (collector, handle) = subscriber::mock() .new_span( - span::mock() + span::expect() .named("foo") .with_fields(expect::field("bar").with_value(&5) .and(expect::field("baz").with_value).only()), diff --git a/tracing/tests/subscriber.rs b/tracing/tests/subscriber.rs index 15557c107f..0357d61ac7 100644 --- a/tracing/tests/subscriber.rs +++ b/tracing/tests/subscriber.rs @@ -61,16 +61,16 @@ fn event_macros_dont_infinite_loop() { fn boxed_subscriber() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("bar") + span::expect().named("foo").with_field( + field::expect("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); let subscriber: Box = Box::new(subscriber); @@ -94,20 +94,20 @@ fn arced_subscriber() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("bar") + span::expect().named("foo").with_field( + field::expect("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .event( - event::mock() - .with_fields(field::mock("message").with_value(&display("hello from my event"))), + event::expect() + .with_fields(field::expect("message").with_value(&display("hello from my event"))), ) - .done() + .only() .run_with_handle(); let subscriber: Arc = Arc::new(subscriber);