From 5048b86a3a83e9e8dcec4112d03523690590f63a 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/async_fn.rs | 92 ++--- tracing-attributes/tests/destructuring.rs | 54 +-- tracing-attributes/tests/err.rs | 101 +++-- tracing-attributes/tests/fields.rs | 50 +-- tracing-attributes/tests/follows_from.rs | 26 +- tracing-attributes/tests/instrument.rs | 54 +-- tracing-attributes/tests/levels.rs | 96 ++--- tracing-attributes/tests/names.rs | 24 +- tracing-attributes/tests/parents.rs | 14 +- tracing-attributes/tests/ret.rs | 92 ++--- tracing-attributes/tests/targets.rs | 40 +- tracing-futures/src/lib.rs | 104 +++--- tracing-futures/tests/std_future.rs | 54 +-- tracing-mock/src/event.rs | 40 +- tracing-mock/src/expectation.rs | 22 +- tracing-mock/src/field.rs | 88 ++--- tracing-mock/src/layer.rs | 69 ++-- tracing-mock/src/metadata.rs | 19 +- tracing-mock/src/span.rs | 38 +- tracing-mock/src/subscriber.rs | 32 +- ...d_layer_filters_dont_break_other_layers.rs | 20 +- tracing-subscriber/tests/env_filter/main.rs | 152 ++++---- .../tests/env_filter/per_layer.rs | 74 ++-- tracing-subscriber/tests/field_filter.rs | 48 +-- tracing-subscriber/tests/filter_log.rs | 8 +- ...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 +- tracing-subscriber/tests/same_len_filters.rs | 26 +- ...d_layer_filters_dont_break_other_layers.rs | 20 +- tracing-subscriber/tests/utils.rs | 4 +- .../vec_subscriber_filter_interests_cached.rs | 31 +- tracing/tests/enabled.rs | 4 +- tracing/tests/event.rs | 166 +++++---- tracing/tests/filters_dont_leak.rs | 12 +- tracing/tests/instrument.rs | 22 +- tracing/tests/max_level_hint.rs | 8 +- tracing/tests/multiple_max_level_hints.rs | 18 +- tracing/tests/no_subscriber.rs | 11 +- tracing/tests/scoped_clobbers_default.rs | 4 +- tracing/tests/span.rs | 344 +++++++++--------- tracing/tests/subscriber.rs | 28 +- 50 files changed, 1276 insertions(+), 1194 deletions(-) diff --git a/tracing-attributes/tests/async_fn.rs b/tracing-attributes/tests/async_fn.rs index d6d874ffd7..924d46bed6 100644 --- a/tracing-attributes/tests/async_fn.rs +++ b/tracing-attributes/tests/async_fn.rs @@ -84,16 +84,16 @@ fn repro_1831_2() -> impl Future> { #[test] fn async_fn_only_enters_for_polls() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("test_async_fn")) - .enter(span::mock().named("test_async_fn")) - .event(event::mock().with_fields(field::mock("awaiting").with_value(&true))) - .exit(span::mock().named("test_async_fn")) - .enter(span::mock().named("test_async_fn")) - .exit(span::mock().named("test_async_fn")) - .enter(span::mock().named("test_async_fn")) - .exit(span::mock().named("test_async_fn")) - .drop_span(span::mock().named("test_async_fn")) - .done() + .new_span(span::expect().named("test_async_fn")) + .enter(span::expect().named("test_async_fn")) + .event(event::expect().with_fields(field::expect("awaiting").with_value(&true))) + .exit(span::expect().named("test_async_fn")) + .enter(span::expect().named("test_async_fn")) + .exit(span::expect().named("test_async_fn")) + .enter(span::expect().named("test_async_fn")) + .exit(span::expect().named("test_async_fn")) + .drop_span(span::expect().named("test_async_fn")) + .only() .run_with_handle(); with_default(subscriber, || { block_on_future(async { test_async_fn(2).await }).unwrap(); @@ -113,14 +113,14 @@ fn async_fn_nested() { tracing::trace!(nested = true); } - let span = span::mock().named("test_async_fns_nested"); - let span2 = span::mock().named("test_async_fns_nested_other"); + let span = span::expect().named("test_async_fns_nested"); + let span2 = span::expect().named("test_async_fns_nested_other"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .new_span(span2.clone()) .enter(span2.clone()) - .event(event::mock().with_fields(field::mock("nested").with_value(&true))) + .event(event::expect().with_fields(field::expect("nested").with_value(&true))) .exit(span2.clone()) .enter(span2.clone()) .exit(span2.clone()) @@ -129,7 +129,7 @@ fn async_fn_nested() { .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -191,26 +191,26 @@ fn async_fn_with_async_trait() { } } - let span = span::mock().named("foo"); - let span2 = span::mock().named("bar"); - let span3 = span::mock().named("baz"); + let span = span::expect().named("foo"); + let span2 = span::expect().named("bar"); + let span3 = span::expect().named("baz"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::mock("self")) - .with_field(field::mock("v")), + .with_field(field::expect("self")) + .with_field(field::expect("v")), ) .enter(span.clone()) .new_span(span3.clone()) .enter(span3.clone()) - .event(event::mock().with_fields(field::mock("val").with_value(&2u64))) + .event(event::expect().with_fields(field::expect("val").with_value(&2u64))) .exit(span3.clone()) .enter(span3.clone()) .exit(span3.clone()) .drop_span(span3) - .new_span(span2.clone().with_field(field::mock("self"))) + .new_span(span2.clone().with_field(field::expect("self"))) .enter(span2.clone()) - .event(event::mock().with_fields(field::mock("val").with_value(&5u64))) + .event(event::expect().with_fields(field::expect("val").with_value(&5u64))) .exit(span2.clone()) .enter(span2.clone()) .exit(span2.clone()) @@ -219,7 +219,7 @@ fn async_fn_with_async_trait() { .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -255,15 +255,15 @@ fn async_fn_with_async_trait_and_fields_expressions() { async fn call(&mut self, _v: usize) {} } - let span = span::mock().named("call"); + let span = span::expect().named("call"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("_v") + field::expect("_v") .with_value(&5usize) - .and(field::mock("test").with_value(&tracing::field::debug(10))) - .and(field::mock("val").with_value(&42u64)) - .and(field::mock("val2").with_value(&42u64)), + .and(field::expect("test").with_value(&tracing::field::debug(10))) + .and(field::expect("val").with_value(&42u64)) + .and(field::expect("val2").with_value(&42u64)), ), ) .enter(span.clone()) @@ -271,7 +271,7 @@ fn async_fn_with_async_trait_and_fields_expressions() { .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -322,27 +322,27 @@ fn async_fn_with_async_trait_and_fields_expressions_with_generic_parameter() { async fn call_with_mut_self(&mut self) {} } - //let span = span::mock().named("call"); - let span2 = span::mock().named("call_with_self"); - let span3 = span::mock().named("call_with_mut_self"); - let span4 = span::mock().named("sync_fun"); + //let span = span::expect().named("call"); + let span2 = span::expect().named("call_with_self"); + let span3 = span::expect().named("call_with_mut_self"); + let span4 = span::expect().named("sync_fun"); let (subscriber, handle) = subscriber::mock() /*.new_span(span.clone() .with_field( - field::mock("Self").with_value(&"TestImpler"))) + field::expect("Self").with_value(&"TestImpler"))) .enter(span.clone()) .exit(span.clone()) .drop_span(span)*/ .new_span( span2 .clone() - .with_field(field::mock("Self").with_value(&std::any::type_name::())), + .with_field(field::expect("Self").with_value(&std::any::type_name::())), ) .enter(span2.clone()) .new_span( span4 .clone() - .with_field(field::mock("Self").with_value(&std::any::type_name::())), + .with_field(field::expect("Self").with_value(&std::any::type_name::())), ) .enter(span4.clone()) .exit(span4.clone()) @@ -355,14 +355,14 @@ fn async_fn_with_async_trait_and_fields_expressions_with_generic_parameter() { .new_span( span3 .clone() - .with_field(field::mock("Self").with_value(&std::any::type_name::())), + .with_field(field::expect("Self").with_value(&std::any::type_name::())), ) .enter(span3.clone()) .exit(span3.clone()) .enter(span3.clone()) .exit(span3.clone()) .drop_span(span3) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -397,7 +397,7 @@ fn out_of_scope_fields() { } } - let span = span::mock().named("call"); + let span = span::expect().named("call"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) @@ -405,7 +405,7 @@ fn out_of_scope_fields() { .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -430,8 +430,8 @@ fn manual_impl_future() { } } - let span = span::mock().named("manual_impl_future"); - let poll_event = || event::mock().with_fields(field::mock("poll").with_value(&true)); + let span = span::expect().named("manual_impl_future"); + let poll_event = || event::expect().with_fields(field::expect("poll").with_value(&true)); let (subscriber, handle) = subscriber::mock() // await manual_impl_future @@ -442,7 +442,7 @@ fn manual_impl_future() { .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -463,8 +463,8 @@ fn manual_box_pin() { }) } - let span = span::mock().named("manual_box_pin"); - let poll_event = || event::mock().with_fields(field::mock("poll").with_value(&true)); + let span = span::expect().named("manual_box_pin"); + let poll_event = || event::expect().with_fields(field::expect("poll").with_value(&true)); let (subscriber, handle) = subscriber::mock() // await manual_box_pin @@ -475,7 +475,7 @@ fn manual_box_pin() { .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/tracing-attributes/tests/destructuring.rs b/tracing-attributes/tests/destructuring.rs index 09cf1ad534..6adbe501c3 100644 --- a/tracing-attributes/tests/destructuring.rs +++ b/tracing-attributes/tests/destructuring.rs @@ -7,21 +7,21 @@ fn destructure_tuples() { #[instrument] fn my_fn((arg1, arg2): (usize, usize)) {} - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) + .and(field::expect("arg2").with_value(&format_args!("2"))) .only(), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -36,23 +36,23 @@ fn destructure_nested_tuples() { #[instrument] fn my_fn(((arg1, arg2), (arg3, arg4)): ((usize, usize), (usize, usize))) {} - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) - .and(field::mock("arg3").with_value(&format_args!("3"))) - .and(field::mock("arg4").with_value(&format_args!("4"))) + .and(field::expect("arg2").with_value(&format_args!("2"))) + .and(field::expect("arg3").with_value(&format_args!("3"))) + .and(field::expect("arg4").with_value(&format_args!("4"))) .only(), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -67,17 +67,17 @@ fn destructure_refs() { #[instrument] fn my_fn(&arg1: &usize) {} - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::mock("arg1").with_value(&1usize).only()), + .with_field(field::expect("arg1").with_value(&1usize).only()), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -94,21 +94,21 @@ fn destructure_tuple_structs() { #[instrument] fn my_fn(Foo(arg1, arg2): Foo) {} - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) + .and(field::expect("arg2").with_value(&format_args!("2"))) .only(), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -135,21 +135,21 @@ fn destructure_structs() { let _ = (arg1, arg2); } - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) + .and(field::expect("arg2").with_value(&format_args!("2"))) .only(), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -180,23 +180,23 @@ fn destructure_everything() { let _ = (arg1, arg2, arg3, arg4); } - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) - .and(field::mock("arg3").with_value(&format_args!("3"))) - .and(field::mock("arg4").with_value(&format_args!("4"))) + .and(field::expect("arg2").with_value(&format_args!("2"))) + .and(field::expect("arg3").with_value(&format_args!("3"))) + .and(field::expect("arg4").with_value(&format_args!("4"))) .only(), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/tracing-attributes/tests/err.rs b/tracing-attributes/tests/err.rs index 485dd11961..23b28804af 100644 --- a/tracing-attributes/tests/err.rs +++ b/tracing-attributes/tests/err.rs @@ -21,19 +21,40 @@ fn err_suspicious_else() -> Result { #[test] fn test() { - let span = span::mock().named("err"); + let span = span::expect().named("err"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR)) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || err().ok()); 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); @@ -44,23 +65,23 @@ async fn err_async(polls: usize) -> Result { #[test] fn test_async() { - let span = span::mock().named("err_async"); + let span = span::expect().named("err_async"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("awaiting").with_value(&true)) + event::expect() + .with_fields(field::expect("awaiting").with_value(&true)) .at_level(Level::TRACE), ) .exit(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR)) .exit(span.clone()) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { block_on_future(async { err_async(2).await }).ok(); @@ -76,14 +97,14 @@ fn err_mut(out: &mut u8) -> Result<(), TryFromIntError> { #[test] fn test_mut() { - let span = span::mock().named("err_mut"); + let span = span::expect().named("err_mut"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR)) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || err_mut(&mut 0).ok()); handle.assert_finished(); @@ -100,23 +121,23 @@ async fn err_mut_async(polls: usize, out: &mut u8) -> Result<(), TryFromIntError #[test] fn test_mut_async() { - let span = span::mock().named("err_mut_async"); + let span = span::expect().named("err_mut_async"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("awaiting").with_value(&true)) + event::expect() + .with_fields(field::expect("awaiting").with_value(&true)) .at_level(Level::TRACE), ) .exit(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR)) .exit(span.clone()) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { block_on_future(async { err_mut_async(2, &mut 0).await }).ok(); @@ -133,17 +154,17 @@ fn impl_trait_return_type() { Ok(0..x) } - let span = span::mock().named("returns_impl_trait"); + let span = span::expect().named("returns_impl_trait"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::mock("x").with_value(&10usize).only()), + .with_field(field::expect("x").with_value(&10usize).only()), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -162,13 +183,13 @@ fn err_dbg() -> Result { #[test] fn test_err_dbg() { - let span = span::mock().named("err_dbg"); + let span = span::expect().named("err_dbg"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock().at_level(Level::ERROR).with_fields( - field::mock("error") + event::expect().at_level(Level::ERROR).with_fields( + field::expect("error") // use the actual error value that will be emitted, so // that this test doesn't break if the standard library // changes the `fmt::Debug` output from the error type @@ -178,7 +199,7 @@ fn test_err_dbg() { ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || err_dbg().ok()); handle.assert_finished(); @@ -186,20 +207,20 @@ fn test_err_dbg() { #[test] fn test_err_display_default() { - let span = span::mock().named("err"); + let span = span::expect().named("err"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock().at_level(Level::ERROR).with_fields( - field::mock("error") + event::expect().at_level(Level::ERROR).with_fields( + field::expect("error") // by default, errors will be emitted with their display values .with_value(&tracing::field::display(u8::try_from(1234).unwrap_err())), ), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || err().ok()); handle.assert_finished(); @@ -208,19 +229,19 @@ fn test_err_display_default() { #[test] fn test_err_custom_target() { let filter: EnvFilter = "my_target=error".parse().expect("filter should parse"); - let span = span::mock().named("error_span").with_target("my_target"); + let span = span::expect().named("error_span").with_target("my_target"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() + event::expect() .at_level(Level::ERROR) .with_target("my_target"), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -243,14 +264,14 @@ fn err_info() -> Result { #[test] fn test_err_info() { - let span = span::mock().named("err_info"); + let span = span::expect().named("err_info"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::INFO)) + .event(event::expect().at_level(Level::INFO)) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || err_info().ok()); handle.assert_finished(); @@ -263,13 +284,13 @@ fn err_dbg_info() -> Result { #[test] fn test_err_dbg_info() { - let span = span::mock().named("err_dbg_info"); + let span = span::expect().named("err_dbg_info"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock().at_level(Level::INFO).with_fields( - field::mock("error") + event::expect().at_level(Level::INFO).with_fields( + field::expect("error") // use the actual error value that will be emitted, so // that this test doesn't break if the standard library // changes the `fmt::Debug` output from the error type @@ -279,7 +300,7 @@ fn test_err_dbg_info() { ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || err_dbg_info().ok()); handle.assert_finished(); @@ -292,14 +313,14 @@ fn err_warn_info() -> Result { #[test] fn test_err_warn_info() { - let span = span::mock().named("err_warn_info").at_level(Level::WARN); + let span = span::expect().named("err_warn_info").at_level(Level::WARN); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::INFO)) + .event(event::expect().at_level(Level::INFO)) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || err_warn_info().ok()); handle.assert_finished(); diff --git a/tracing-attributes/tests/fields.rs b/tracing-attributes/tests/fields.rs index c178fbb3d3..5911b393b7 100644 --- a/tracing-attributes/tests/fields.rs +++ b/tracing-attributes/tests/fields.rs @@ -1,6 +1,6 @@ use tracing::subscriber::with_default; use tracing_attributes::instrument; -use tracing_mock::field::mock; +use tracing_mock::field::expect; use tracing_mock::span::NewSpan; use tracing_mock::*; @@ -48,11 +48,11 @@ impl HasField { #[test] fn fields() { - let span = span::mock().with_field( - mock("foo") + let span = span::expect().with_field( + expect("foo") .with_value(&"bar") - .and(mock("dsa").with_value(&true)) - .and(mock("num").with_value(&1)) + .and(expect("dsa").with_value(&true)) + .and(expect("num").with_value(&1)) .only(), ); run_test(span, || { @@ -62,10 +62,10 @@ fn fields() { #[test] fn expr_field() { - let span = span::mock().with_field( - mock("s") + let span = span::expect().with_field( + expect("s") .with_value(&"hello world") - .and(mock("len").with_value(&"hello world".len())) + .and(expect("len").with_value(&"hello world".len())) .only(), ); run_test(span, || { @@ -75,11 +75,11 @@ fn expr_field() { #[test] fn two_expr_fields() { - let span = span::mock().with_field( - mock("s") + let span = span::expect().with_field( + expect("s") .with_value(&"hello world") - .and(mock("s.len").with_value(&"hello world".len())) - .and(mock("s.is_empty").with_value(&false)) + .and(expect("s.len").with_value(&"hello world".len())) + .and(expect("s.is_empty").with_value(&false)) .only(), ); run_test(span, || { @@ -89,19 +89,19 @@ fn two_expr_fields() { #[test] fn clashy_expr_field() { - let span = span::mock().with_field( + let span = span::expect().with_field( // Overriding the `s` field should record `s` as a `Display` value, // rather than as a `Debug` value. - mock("s") + expect("s") .with_value(&tracing::field::display("hello world")) - .and(mock("s.len").with_value(&"hello world".len())) + .and(expect("s.len").with_value(&"hello world".len())) .only(), ); run_test(span, || { fn_clashy_expr_field("hello world"); }); - let span = span::mock().with_field(mock("s").with_value(&"s").only()); + let span = span::expect().with_field(expect("s").with_value(&"s").only()); run_test(span, || { fn_clashy_expr_field2("hello world"); }); @@ -109,7 +109,7 @@ fn clashy_expr_field() { #[test] fn self_expr_field() { - let span = span::mock().with_field(mock("my_field").with_value(&"hello world").only()); + let span = span::expect().with_field(expect("my_field").with_value(&"hello world").only()); run_test(span, || { let has_field = HasField { my_field: "hello world", @@ -120,10 +120,10 @@ fn self_expr_field() { #[test] fn parameters_with_fields() { - let span = span::mock().with_field( - mock("foo") + let span = span::expect().with_field( + expect("foo") .with_value(&"bar") - .and(mock("param").with_value(&1u32)) + .and(expect("param").with_value(&1u32)) .only(), ); run_test(span, || { @@ -133,7 +133,7 @@ fn parameters_with_fields() { #[test] fn empty_field() { - let span = span::mock().with_field(mock("foo").with_value(&"bar").only()); + let span = span::expect().with_field(expect("foo").with_value(&"bar").only()); run_test(span, || { fn_empty_field(); }); @@ -141,7 +141,7 @@ fn empty_field() { #[test] fn string_field() { - let span = span::mock().with_field(mock("s").with_value(&"hello world").only()); + let span = span::expect().with_field(expect("s").with_value(&"hello world").only()); run_test(span, || { fn_string(String::from("hello world")); }); @@ -150,9 +150,9 @@ fn string_field() { fn run_test T, T>(span: NewSpan, fun: F) { let (subscriber, handle) = subscriber::mock() .new_span(span) - .enter(span::mock()) - .exit(span::mock()) - .done() + .enter(span::expect()) + .exit(span::expect()) + .only() .run_with_handle(); with_default(subscriber, fun); diff --git a/tracing-attributes/tests/follows_from.rs b/tracing-attributes/tests/follows_from.rs index a589409ded..4295442865 100644 --- a/tracing-attributes/tests/follows_from.rs +++ b/tracing-attributes/tests/follows_from.rs @@ -13,10 +13,10 @@ fn follows_from_current() {} #[test] fn follows_from_sync_test() { - let cause_a = span::mock().named("cause_a"); - let cause_b = span::mock().named("cause_b"); - let cause_c = span::mock().named("cause_c"); - let consequence = span::mock().named("with_follows_from_sync"); + let cause_a = span::expect().named("cause_a"); + let cause_b = span::expect().named("cause_b"); + let cause_c = span::expect().named("cause_c"); + let consequence = span::expect().named("with_follows_from_sync"); let (subscriber, handle) = subscriber::mock() .new_span(cause_a.clone()) @@ -28,7 +28,7 @@ fn follows_from_sync_test() { .follows_from(consequence.clone(), cause_c) .enter(consequence.clone()) .exit(consequence) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -44,10 +44,10 @@ fn follows_from_sync_test() { #[test] fn follows_from_async_test() { - let cause_a = span::mock().named("cause_a"); - let cause_b = span::mock().named("cause_b"); - let cause_c = span::mock().named("cause_c"); - let consequence = span::mock().named("with_follows_from_async"); + let cause_a = span::expect().named("cause_a"); + let cause_b = span::expect().named("cause_b"); + let cause_c = span::expect().named("cause_c"); + let consequence = span::expect().named("with_follows_from_async"); let (subscriber, handle) = subscriber::mock() .new_span(cause_a.clone()) @@ -61,7 +61,7 @@ fn follows_from_async_test() { .exit(consequence.clone()) .enter(consequence.clone()) .exit(consequence) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -79,8 +79,8 @@ fn follows_from_async_test() { #[test] fn follows_from_current_test() { - let cause = span::mock().named("cause"); - let consequence = span::mock().named("follows_from_current"); + let cause = span::expect().named("cause"); + let consequence = span::expect().named("follows_from_current"); let (subscriber, handle) = subscriber::mock() .new_span(cause.clone()) @@ -90,7 +90,7 @@ fn follows_from_current_test() { .enter(consequence.clone()) .exit(consequence) .exit(cause) - .done() + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/tracing-attributes/tests/instrument.rs b/tracing-attributes/tests/instrument.rs index b215b8455d..41b853c8e0 100644 --- a/tracing-attributes/tests/instrument.rs +++ b/tracing-attributes/tests/instrument.rs @@ -20,11 +20,11 @@ fn override_everything() { #[instrument(level = Level::DEBUG, target = "my_target")] fn my_other_fn() {} - let span = span::mock() + let span = span::expect() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::mock() + let span2 = span::expect() .named("my_other_fn") .at_level(Level::DEBUG) .with_target("my_target"); @@ -37,7 +37,7 @@ fn override_everything() { .enter(span2.clone()) .exit(span2.clone()) .drop_span(span2) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -53,21 +53,21 @@ fn fields() { #[instrument(target = "my_target", level = "debug")] fn my_fn(arg1: usize, arg2: bool) {} - let span = span::mock() + let span = span::expect() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::mock() + let span2 = span::expect() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&2usize) - .and(field::mock("arg2").with_value(&false)) + .and(field::expect("arg2").with_value(&false)) .only(), ), ) @@ -76,16 +76,16 @@ fn fields() { .drop_span(span) .new_span( span2.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&3usize) - .and(field::mock("arg2").with_value(&true)) + .and(field::expect("arg2").with_value(&true)) .only(), ), ) .enter(span2.clone()) .exit(span2.clone()) .drop_span(span2) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -106,17 +106,17 @@ fn skip() { #[instrument(target = "my_target", level = "debug", skip_all)] fn my_fn2(_arg1: usize, _arg2: UnDebug, _arg3: UnDebug) {} - let span = span::mock() + let span = span::expect() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::mock() + let span2 = span::expect() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span3 = span::mock() + let span3 = span::expect() .named("my_fn2") .at_level(Level::DEBUG) .with_target("my_target"); @@ -124,7 +124,7 @@ fn skip() { let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::mock("arg1").with_value(&2usize).only()), + .with_field(field::expect("arg1").with_value(&2usize).only()), ) .enter(span.clone()) .exit(span.clone()) @@ -132,7 +132,7 @@ fn skip() { .new_span( span2 .clone() - .with_field(field::mock("arg1").with_value(&3usize).only()), + .with_field(field::expect("arg1").with_value(&3usize).only()), ) .enter(span2.clone()) .exit(span2.clone()) @@ -141,7 +141,7 @@ fn skip() { .enter(span3.clone()) .exit(span3.clone()) .drop_span(span3) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -165,20 +165,20 @@ fn generics() { { } - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("Foo")) - .and(field::mock("arg2").with_value(&format_args!("false"))), + .and(field::expect("arg2").with_value(&format_args!("false"))), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -198,20 +198,20 @@ fn methods() { fn my_fn(&self, arg1: usize) {} } - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("self") + field::expect("self") .with_value(&format_args!("Foo")) - .and(field::mock("arg1").with_value(&42usize)), + .and(field::expect("arg1").with_value(&42usize)), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -229,17 +229,17 @@ fn impl_trait_return_type() { 0..x } - let span = span::mock().named("returns_impl_trait"); + let span = span::expect().named("returns_impl_trait"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::mock("x").with_value(&10usize).only()), + .with_field(field::expect("x").with_value(&10usize).only()), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/tracing-attributes/tests/levels.rs b/tracing-attributes/tests/levels.rs index 94fc7e85a2..b4bb1bd907 100644 --- a/tracing-attributes/tests/levels.rs +++ b/tracing-attributes/tests/levels.rs @@ -20,22 +20,22 @@ fn named_levels() { #[instrument(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, || { @@ -66,22 +66,22 @@ fn numeric_levels() { #[instrument(level = 5)] 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, || { @@ -112,22 +112,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/names.rs b/tracing-attributes/tests/names.rs index d97dece9a1..6161c68053 100644 --- a/tracing-attributes/tests/names.rs +++ b/tracing-attributes/tests/names.rs @@ -17,10 +17,10 @@ fn custom_name_no_equals() {} #[test] fn default_name_test() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("default_name")) - .enter(span::mock().named("default_name")) - .exit(span::mock().named("default_name")) - .done() + .new_span(span::expect().named("default_name")) + .enter(span::expect().named("default_name")) + .exit(span::expect().named("default_name")) + .only() .run_with_handle(); with_default(subscriber, || { @@ -33,10 +33,10 @@ fn default_name_test() { #[test] fn custom_name_test() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("my_name")) - .enter(span::mock().named("my_name")) - .exit(span::mock().named("my_name")) - .done() + .new_span(span::expect().named("my_name")) + .enter(span::expect().named("my_name")) + .exit(span::expect().named("my_name")) + .only() .run_with_handle(); with_default(subscriber, || { @@ -49,10 +49,10 @@ fn custom_name_test() { #[test] fn custom_name_no_equals_test() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("my_other_name")) - .enter(span::mock().named("my_other_name")) - .exit(span::mock().named("my_other_name")) - .done() + .new_span(span::expect().named("my_other_name")) + .enter(span::expect().named("my_other_name")) + .exit(span::expect().named("my_other_name")) + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/tracing-attributes/tests/parents.rs b/tracing-attributes/tests/parents.rs index 7069b98ea5..d3069f3063 100644 --- a/tracing-attributes/tests/parents.rs +++ b/tracing-attributes/tests/parents.rs @@ -14,8 +14,8 @@ where #[test] fn default_parent_test() { - let contextual_parent = span::mock().named("contextual_parent"); - let child = span::mock().named("with_default_parent"); + let contextual_parent = span::expect().named("contextual_parent"); + let child = span::expect().named("with_default_parent"); let (subscriber, handle) = subscriber::mock() .new_span( @@ -42,7 +42,7 @@ fn default_parent_test() { .enter(child.clone()) .exit(child) .exit(contextual_parent) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -60,9 +60,9 @@ fn default_parent_test() { #[test] fn explicit_parent_test() { - let contextual_parent = span::mock().named("contextual_parent"); - let explicit_parent = span::mock().named("explicit_parent"); - let child = span::mock().named("with_explicit_parent"); + let contextual_parent = span::expect().named("contextual_parent"); + let explicit_parent = span::expect().named("explicit_parent"); + let child = span::expect().named("with_explicit_parent"); let (subscriber, handle) = subscriber::mock() .new_span( @@ -86,7 +86,7 @@ fn explicit_parent_test() { .enter(child.clone()) .exit(child) .exit(contextual_parent) - .done() + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/tracing-attributes/tests/ret.rs b/tracing-attributes/tests/ret.rs index f56c80baaf..40275df3fd 100644 --- a/tracing-attributes/tests/ret.rs +++ b/tracing-attributes/tests/ret.rs @@ -19,18 +19,18 @@ fn ret_with_target() -> i32 { #[test] fn test() { - let span = span::mock().named("ret"); + let span = span::expect().named("ret"); 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); @@ -40,7 +40,7 @@ fn test() { #[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"); @@ -48,14 +48,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); @@ -71,18 +71,18 @@ fn ret_warn() -> i32 { #[test] fn test_warn() { - let span = span::mock().named("ret_warn"); + let span = span::expect().named("ret_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::WARN), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, ret_warn); @@ -98,23 +98,23 @@ fn ret_mut(a: &mut i32) -> i32 { #[test] fn test_mut() { - let span = span::mock().named("ret_mut"); + let span = span::expect().named("ret_mut"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("a").with_value(&tracing::field::display(2))) + event::expect() + .with_fields(field::expect("a").with_value(&tracing::field::display(2))) .at_level(Level::INFO), ) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(2))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(2))) .at_level(Level::INFO), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || ret_mut(&mut 1)); @@ -128,20 +128,20 @@ async fn ret_async() -> i32 { #[test] fn test_async() { - let span = span::mock().named("ret_async"); + let span = span::expect().named("ret_async"); 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()) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || block_on_future(async { ret_async().await })); @@ -155,18 +155,18 @@ fn ret_impl_type() -> impl Copy { #[test] fn test_impl_type() { - let span = span::mock().named("ret_impl_type"); + let span = span::expect().named("ret_impl_type"); 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_impl_type); @@ -180,18 +180,18 @@ fn ret_display() -> i32 { #[test] fn test_dbg() { - let span = span::mock().named("ret_display"); + let span = span::expect().named("ret_display"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::display(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::display(42))) .at_level(Level::INFO), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, ret_display); @@ -205,14 +205,14 @@ fn ret_and_err() -> Result { #[test] fn test_ret_and_err() { - let span = span::mock().named("ret_and_err"); + let span = span::expect().named("ret_and_err"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() + event::expect() .with_fields( - field::mock("error") + field::expect("error") .with_value(&tracing::field::display(u8::try_from(1234).unwrap_err())) .only(), ) @@ -220,7 +220,7 @@ fn test_ret_and_err() { ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || ret_and_err().ok()); @@ -234,14 +234,14 @@ fn ret_and_ok() -> Result { #[test] fn test_ret_and_ok() { - let span = span::mock().named("ret_and_ok"); + let span = span::expect().named("ret_and_ok"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() + event::expect() .with_fields( - field::mock("return") + field::expect("return") .with_value(&tracing::field::debug(u8::try_from(123).unwrap())) .only(), ) @@ -249,7 +249,7 @@ fn test_ret_and_ok() { ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || ret_and_ok().ok()); @@ -263,18 +263,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); @@ -288,18 +288,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-attributes/tests/targets.rs b/tracing-attributes/tests/targets.rs index 363f628f31..3a545ebff9 100644 --- a/tracing-attributes/tests/targets.rs +++ b/tracing-attributes/tests/targets.rs @@ -24,36 +24,36 @@ mod my_mod { fn default_targets() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock() + span::expect() .named("default_target") .with_target(module_path!()), ) .enter( - span::mock() + span::expect() .named("default_target") .with_target(module_path!()), ) .exit( - span::mock() + span::expect() .named("default_target") .with_target(module_path!()), ) .new_span( - span::mock() + span::expect() .named("default_target") .with_target(my_mod::MODULE_PATH), ) .enter( - span::mock() + span::expect() .named("default_target") .with_target(my_mod::MODULE_PATH), ) .exit( - span::mock() + span::expect() .named("default_target") .with_target(my_mod::MODULE_PATH), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -67,25 +67,37 @@ fn default_targets() { #[test] fn custom_targets() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("custom_target").with_target("my_target")) - .enter(span::mock().named("custom_target").with_target("my_target")) - .exit(span::mock().named("custom_target").with_target("my_target")) .new_span( - span::mock() + span::expect() + .named("custom_target") + .with_target("my_target"), + ) + .enter( + span::expect() + .named("custom_target") + .with_target("my_target"), + ) + .exit( + span::expect() + .named("custom_target") + .with_target("my_target"), + ) + .new_span( + span::expect() .named("custom_target") .with_target("my_other_target"), ) .enter( - span::mock() + span::expect() .named("custom_target") .with_target("my_other_target"), ) .exit( - span::mock() + span::expect() .named("custom_target") .with_target("my_other_target"), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/tracing-futures/src/lib.rs b/tracing-futures/src/lib.rs index 8065175d28..2795d87253 100644 --- a/tracing-futures/src/lib.rs +++ b/tracing-futures/src/lib.rs @@ -634,14 +634,14 @@ mod tests { #[test] fn future_enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .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")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { PollN::new_ok(2) @@ -655,14 +655,14 @@ mod tests { #[test] fn future_error_ends_span() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .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")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { PollN::new_err(2) @@ -677,17 +677,17 @@ mod tests { #[test] fn stream_enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .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")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .run_with_handle(); with_default(subscriber, || { stream::iter_ok::<_, ()>(&[1, 2, 3]) @@ -702,15 +702,15 @@ mod tests { // #[test] // fn span_follows_future_onto_threadpool() { // let (subscriber, handle) = subscriber::mock() - // .enter(span::mock().named("a")) - // .enter(span::mock().named("b")) - // .exit(span::mock().named("b")) - // .enter(span::mock().named("b")) - // .exit(span::mock().named("b")) - // .drop_span(span::mock().named("b")) - // .exit(span::mock().named("a")) - // .drop_span(span::mock().named("a")) - // .done() + // .enter(span::expect().named("a")) + // .enter(span::expect().named("b")) + // .exit(span::expect().named("b")) + // .enter(span::expect().named("b")) + // .exit(span::expect().named("b")) + // .drop_span(span::expect().named("b")) + // .exit(span::expect().named("a")) + // .drop_span(span::expect().named("a")) + // .only() // .run_with_handle(); // let mut runtime = tokio::runtime::Runtime::new().unwrap(); // with_default(subscriber, || { @@ -740,15 +740,15 @@ mod tests { #[test] fn stream_enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .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")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .run_with_handle(); with_default(subscriber, || { Instrument::instrument(stream::iter(&[1, 2, 3]), tracing::trace_span!("foo")) @@ -762,13 +762,13 @@ mod tests { #[test] fn sink_enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .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")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .run_with_handle(); with_default(subscriber, || { Instrument::instrument(sink::drain(), tracing::trace_span!("foo")) diff --git a/tracing-futures/tests/std_future.rs b/tracing-futures/tests/std_future.rs index 8bc31149c7..71f888ce0b 100644 --- a/tracing-futures/tests/std_future.rs +++ b/tracing-futures/tests/std_future.rs @@ -8,14 +8,14 @@ use tracing_mock::*; #[test] fn enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .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")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { let future = PollN::new_ok(2).instrument(tracing::span!(Level::TRACE, "foo")); @@ -27,14 +27,14 @@ fn enter_exit_is_reasonable() { #[test] fn error_ends_span() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .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")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { let future = PollN::new_err(2).instrument(tracing::span!(Level::TRACE, "foo")); @@ -66,17 +66,17 @@ fn span_on_drop() { } let subscriber = subscriber::mock() - .enter(span::mock().named("foo")) - .event(event::mock().at_level(Level::INFO)) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .enter(span::mock().named("bar")) - .event(event::mock().at_level(Level::INFO)) - .exit(span::mock().named("bar")) - .drop_span(span::mock().named("bar")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect().at_level(Level::INFO)) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .enter(span::expect().named("bar")) + .event(event::expect().at_level(Level::INFO)) + .exit(span::expect().named("bar")) + .drop_span(span::expect().named("bar")) + .only() .run(); with_default(subscriber, || { diff --git a/tracing-mock/src/event.rs b/tracing-mock/src/event.rs index 9e57864964..cd3bef76a3 100644 --- a/tracing-mock/src/event.rs +++ b/tracing-mock/src/event.rs @@ -1,5 +1,5 @@ #![allow(missing_docs)] -use super::{field, metadata, span, Parent}; +use super::{field, metadata::ExpectedMetadata, span, Parent}; use std::fmt; @@ -8,30 +8,30 @@ use std::fmt; /// This is intended for use with the mock subscriber API in the /// `subscriber` module. #[derive(Default, Eq, PartialEq)] -pub struct MockEvent { - pub fields: Option, - in_spans: Vec, - pub(crate) parent: Option, - metadata: metadata::Expect, +pub struct ExpectedEvent { + fields: Option, + parent: Option, + in_spans: Vec, + metadata: ExpectedMetadata, } -pub fn mock() -> MockEvent { - MockEvent { +pub fn expect() -> ExpectedEvent { + ExpectedEvent { ..Default::default() } } -pub fn msg(message: impl fmt::Display) -> MockEvent { - mock().with_fields(field::msg(message)) +pub fn msg(message: impl fmt::Display) -> ExpectedEvent { + expect().with_fields(field::msg(message)) } -impl MockEvent { +impl ExpectedEvent { pub fn named(self, name: I) -> Self where I: Into, { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { name: Some(name.into()), ..self.metadata }, @@ -41,7 +41,7 @@ impl MockEvent { pub fn with_fields(self, fields: I) -> Self where - I: Into, + I: Into, { Self { fields: Some(fields.into()), @@ -51,7 +51,7 @@ impl MockEvent { pub fn at_level(self, level: tracing::Level) -> Self { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { level: Some(level), ..self.metadata }, @@ -64,7 +64,7 @@ impl MockEvent { I: Into, { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { target: Some(target.into()), ..self.metadata }, @@ -72,7 +72,7 @@ impl MockEvent { } } - pub fn with_explicit_parent(self, parent: Option<&str>) -> MockEvent { + pub fn with_explicit_parent(self, parent: Option<&str>) -> ExpectedEvent { let parent = match parent { Some(name) => Parent::Explicit(name.into()), None => Parent::ExplicitRoot, @@ -117,25 +117,25 @@ impl MockEvent { } } - pub fn in_scope(self, spans: impl IntoIterator) -> Self { + pub fn in_scope(self, spans: impl IntoIterator) -> Self { Self { in_spans: spans.into_iter().collect(), ..self } } - pub fn scope_mut(&mut self) -> &mut [span::MockSpan] { + pub fn scope_mut(&mut self) -> &mut [span::ExpectedSpan] { &mut self.in_spans[..] } } -impl fmt::Display for MockEvent { +impl fmt::Display for ExpectedEvent { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "an event{}", self.metadata) } } -impl fmt::Debug for MockEvent { +impl fmt::Debug for ExpectedEvent { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut s = f.debug_struct("MockEvent"); 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/field.rs b/tracing-mock/src/field.rs index bdf22aba1d..be3f9c47cf 100644 --- a/tracing-mock/src/field.rs +++ b/tracing-mock/src/field.rs @@ -8,19 +8,19 @@ use tracing::{ use std::{collections::HashMap, fmt}; #[derive(Default, Debug, Eq, PartialEq)] -pub struct Expect { - fields: HashMap, +pub struct ExpectedFields { + fields: HashMap, only: bool, } #[derive(Debug)] -pub struct MockField { +pub struct ExpectedField { name: String, - value: MockValue, + value: ExpectedValue, } #[derive(Debug)] -pub enum MockValue { +pub enum ExpectedValue { F64(f64), I64(i64), U64(u64), @@ -30,11 +30,11 @@ pub enum MockValue { Any, } -impl Eq for MockValue {} +impl Eq for ExpectedValue {} -impl PartialEq for MockValue { +impl PartialEq for ExpectedValue { fn eq(&self, other: &Self) -> bool { - use MockValue::*; + use ExpectedValue::*; match (self, other) { (F64(a), F64(b)) => { @@ -55,34 +55,34 @@ impl PartialEq for MockValue { } } -pub fn mock(name: K) -> MockField +pub fn expect(name: K) -> ExpectedField where String: From, { - MockField { + ExpectedField { name: name.into(), - value: MockValue::Any, + value: ExpectedValue::Any, } } -pub fn msg(message: impl fmt::Display) -> MockField { - MockField { +pub fn msg(message: impl fmt::Display) -> ExpectedField { + ExpectedField { name: "message".to_string(), - value: MockValue::Debug(message.to_string()), + value: ExpectedValue::Debug(message.to_string()), } } -impl MockField { +impl ExpectedField { /// Expect a field with the given name and value. pub fn with_value(self, value: &dyn Value) -> Self { Self { - value: MockValue::from(value), + value: ExpectedValue::from(value), ..self } } - pub fn and(self, other: MockField) -> Expect { - Expect { + pub fn and(self, other: ExpectedField) -> ExpectedFields { + ExpectedFields { fields: HashMap::new(), only: false, } @@ -90,8 +90,8 @@ impl MockField { .and(other) } - pub fn only(self) -> Expect { - Expect { + pub fn only(self) -> ExpectedFields { + ExpectedFields { fields: HashMap::new(), only: true, } @@ -99,9 +99,9 @@ impl MockField { } } -impl From for Expect { - fn from(field: MockField) -> Self { - Expect { +impl From for ExpectedFields { + fn from(field: ExpectedField) -> Self { + ExpectedFields { fields: HashMap::new(), only: false, } @@ -109,8 +109,8 @@ impl From for Expect { } } -impl Expect { - pub fn and(mut self, field: MockField) -> Self { +impl ExpectedFields { + pub fn and(mut self, field: ExpectedField) -> Self { self.fields.insert(field.name, field.value); self } @@ -129,7 +129,7 @@ impl Expect { ) { let value = value.into(); match self.fields.remove(name) { - Some(MockValue::Any) => {} + Some(ExpectedValue::Any) => {} Some(expected) => assert!( expected == value, "\n[{}] expected `{}` to contain:\n\t`{}{}`\nbut got:\n\t`{}{}`", @@ -161,22 +161,22 @@ impl Expect { } } -impl fmt::Display for MockValue { +impl fmt::Display for ExpectedValue { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { - MockValue::F64(v) => write!(f, "f64 = {:?}", v), - MockValue::I64(v) => write!(f, "i64 = {:?}", v), - MockValue::U64(v) => write!(f, "u64 = {:?}", v), - MockValue::Bool(v) => write!(f, "bool = {:?}", v), - MockValue::Str(v) => write!(f, "&str = {:?}", v), - MockValue::Debug(v) => write!(f, "&fmt::Debug = {:?}", v), - MockValue::Any => write!(f, "_ = _"), + ExpectedValue::F64(v) => write!(f, "f64 = {:?}", v), + ExpectedValue::I64(v) => write!(f, "i64 = {:?}", v), + ExpectedValue::U64(v) => write!(f, "u64 = {:?}", v), + ExpectedValue::Bool(v) => write!(f, "bool = {:?}", v), + ExpectedValue::Str(v) => write!(f, "&str = {:?}", v), + ExpectedValue::Debug(v) => write!(f, "&fmt::Debug = {:?}", v), + ExpectedValue::Any => write!(f, "_ = _"), } } } pub struct CheckVisitor<'a> { - expect: &'a mut Expect, + expect: &'a mut ExpectedFields, ctx: &'a str, subscriber_name: &'a str, } @@ -229,35 +229,35 @@ impl<'a> CheckVisitor<'a> { } } -impl<'a> From<&'a dyn Value> for MockValue { +impl<'a> From<&'a dyn Value> for ExpectedValue { fn from(value: &'a dyn Value) -> Self { struct MockValueBuilder { - value: Option, + value: Option, } impl Visit for MockValueBuilder { fn record_f64(&mut self, _: &Field, value: f64) { - self.value = Some(MockValue::F64(value)); + self.value = Some(ExpectedValue::F64(value)); } fn record_i64(&mut self, _: &Field, value: i64) { - self.value = Some(MockValue::I64(value)); + self.value = Some(ExpectedValue::I64(value)); } fn record_u64(&mut self, _: &Field, value: u64) { - self.value = Some(MockValue::U64(value)); + self.value = Some(ExpectedValue::U64(value)); } fn record_bool(&mut self, _: &Field, value: bool) { - self.value = Some(MockValue::Bool(value)); + self.value = Some(ExpectedValue::Bool(value)); } fn record_str(&mut self, _: &Field, value: &str) { - self.value = Some(MockValue::Str(value.to_owned())); + self.value = Some(ExpectedValue::Str(value.to_owned())); } fn record_debug(&mut self, _: &Field, value: &dyn fmt::Debug) { - self.value = Some(MockValue::Debug(format!("{:?}", value))); + self.value = Some(ExpectedValue::Debug(format!("{:?}", value))); } } @@ -274,7 +274,7 @@ impl<'a> From<&'a dyn Value> for MockValue { } } -impl fmt::Display for Expect { +impl fmt::Display for ExpectedFields { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "fields ")?; let entries = self 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-mock/src/metadata.rs b/tracing-mock/src/metadata.rs index 8c4c3a9c89..49347434fe 100644 --- a/tracing-mock/src/metadata.rs +++ b/tracing-mock/src/metadata.rs @@ -2,14 +2,19 @@ use std::fmt; use tracing::Metadata; #[derive(Clone, Debug, Eq, PartialEq, Default)] -pub struct Expect { - pub name: Option, - pub level: Option, - pub target: Option, +pub(crate) struct ExpectedMetadata { + pub(crate) name: Option, + pub(crate) level: Option, + pub(crate) target: Option, } -impl Expect { - pub fn check(&self, actual: &Metadata<'_>, ctx: fmt::Arguments<'_>, subscriber_name: &str) { +impl ExpectedMetadata { + pub(crate) fn check( + &self, + actual: &Metadata<'_>, + ctx: fmt::Arguments<'_>, + subscriber_name: &str, + ) { if let Some(ref expected_name) = self.name { let name = actual.name(); assert!( @@ -48,7 +53,7 @@ impl Expect { } } -impl fmt::Display for Expect { +impl fmt::Display for ExpectedMetadata { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if let Some(ref name) = self.name { write!(f, " named `{}`", name)?; diff --git a/tracing-mock/src/span.rs b/tracing-mock/src/span.rs index a55aaabc93..35cab3ebb9 100644 --- a/tracing-mock/src/span.rs +++ b/tracing-mock/src/span.rs @@ -1,5 +1,5 @@ #![allow(missing_docs)] -use super::{field, metadata, Parent}; +use super::{field::ExpectedFields, metadata::ExpectedMetadata, Parent}; use std::fmt; /// A mock span. @@ -7,37 +7,37 @@ use std::fmt; /// This is intended for use with the mock subscriber API in the /// `subscriber` module. #[derive(Clone, Default, Eq, PartialEq)] -pub struct MockSpan { - pub(crate) metadata: metadata::Expect, +pub struct ExpectedSpan { + pub(crate) metadata: ExpectedMetadata, } #[derive(Default, Eq, PartialEq)] pub struct NewSpan { - pub(crate) span: MockSpan, - pub(crate) fields: field::Expect, + pub(crate) span: ExpectedSpan, + pub(crate) fields: ExpectedFields, pub(crate) parent: Option, } -pub fn mock() -> MockSpan { - MockSpan { +pub fn expect() -> ExpectedSpan { + ExpectedSpan { ..Default::default() } } -pub fn named(name: I) -> MockSpan +pub fn named(name: I) -> ExpectedSpan where I: Into, { - mock().named(name) + expect().named(name) } -impl MockSpan { +impl ExpectedSpan { pub fn named(self, name: I) -> Self where I: Into, { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { name: Some(name.into()), ..self.metadata }, @@ -46,7 +46,7 @@ impl MockSpan { pub fn at_level(self, level: tracing::Level) -> Self { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { level: Some(level), ..self.metadata }, @@ -58,7 +58,7 @@ impl MockSpan { I: Into, { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { target: Some(target.into()), ..self.metadata }, @@ -103,7 +103,7 @@ impl MockSpan { pub fn with_field(self, fields: I) -> NewSpan where - I: Into, + I: Into, { NewSpan { span: self, @@ -113,7 +113,7 @@ impl MockSpan { } } -impl fmt::Debug for MockSpan { +impl fmt::Debug for ExpectedSpan { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut s = f.debug_struct("MockSpan"); @@ -133,7 +133,7 @@ impl fmt::Debug for MockSpan { } } -impl fmt::Display for MockSpan { +impl fmt::Display for ExpectedSpan { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if self.metadata.name.is_some() { write!(f, "a span{}", self.metadata) @@ -143,8 +143,8 @@ impl fmt::Display for MockSpan { } } -impl From for NewSpan { - fn from(span: MockSpan) -> Self { +impl From for NewSpan { + fn from(span: ExpectedSpan) -> Self { Self { span, ..Default::default() @@ -177,7 +177,7 @@ impl NewSpan { pub fn with_field(self, fields: I) -> NewSpan where - I: Into, + I: Into, { NewSpan { fields: fields.into(), diff --git a/tracing-mock/src/subscriber.rs b/tracing-mock/src/subscriber.rs index 9a73da28c2..3049993fe8 100644 --- a/tracing-mock/src/subscriber.rs +++ b/tracing-mock/src/subscriber.rs @@ -1,9 +1,9 @@ #![allow(missing_docs)] -use super::{ - event::MockEvent, +use crate::{ + event::ExpectedEvent, expectation::Expect, - field as mock_field, - span::{MockSpan, NewSpan}, + field::ExpectedFields, + span::{ExpectedSpan, NewSpan}, }; use std::{ collections::{HashMap, VecDeque}, @@ -82,46 +82,46 @@ where } } - pub fn enter(mut self, span: MockSpan) -> Self { + pub fn enter(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::Enter(span)); self } - pub fn follows_from(mut self, consequence: MockSpan, cause: MockSpan) -> Self { + pub fn follows_from(mut self, consequence: ExpectedSpan, cause: ExpectedSpan) -> Self { self.expected .push_back(Expect::FollowsFrom { consequence, cause }); self } - pub fn event(mut self, event: MockEvent) -> Self { + pub fn event(mut self, event: ExpectedEvent) -> Self { self.expected.push_back(Expect::Event(event)); self } - pub fn exit(mut self, span: MockSpan) -> Self { + pub fn exit(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::Exit(span)); self } - pub fn clone_span(mut self, span: MockSpan) -> Self { + pub fn clone_span(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::CloneSpan(span)); self } #[allow(deprecated)] - pub fn drop_span(mut self, span: MockSpan) -> Self { + pub fn drop_span(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::DropSpan(span)); self } - pub fn done(mut self) -> Self { + pub fn only(mut self) -> Self { self.expected.push_back(Expect::Nothing); self } - pub fn record(mut self, span: MockSpan, fields: I) -> Self + pub fn record(mut self, span: ExpectedSpan, fields: I) -> Self where - I: Into, + I: Into, { self.expected.push_back(Expect::Visit(span, fields.into())); self @@ -194,9 +194,7 @@ where Interest::never() } } - fn max_level_hint(&self) -> Option { - println!("[{}] max_level_hint -> {:?}", self.name, self.max_level); self.max_level } @@ -309,8 +307,8 @@ where id.clone(), SpanState { name: meta.name(), - meta, refs: 1, + meta, }, ); id @@ -473,7 +471,7 @@ impl MockHandle { } impl Expect { - pub(crate) fn bad(&self, name: impl AsRef, what: fmt::Arguments<'_>) { + pub fn bad(&self, name: impl AsRef, what: fmt::Arguments<'_>) { let name = name.as_ref(); match self { Expect::Event(e) => panic!( 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/main.rs b/tracing-subscriber/tests/env_filter/main.rs index ef984a68a9..2ec008dd68 100644 --- a/tracing-subscriber/tests/env_filter/main.rs +++ b/tracing-subscriber/tests/env_filter/main.rs @@ -13,10 +13,10 @@ use tracing_subscriber::{ fn level_filter_event() { let filter: EnvFilter = "info".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::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 = subscriber.with(filter); @@ -38,18 +38,18 @@ fn same_name_spans() { .expect("filter should parse"); let (subscriber, finished) = subscriber::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 = subscriber.with(filter); with_default(subscriber, || { @@ -64,12 +64,12 @@ fn same_name_spans() { fn level_filter_event_with_target() { let filter: EnvFilter = "info,stuff=debug".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::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 = subscriber.with(filter); @@ -98,14 +98,14 @@ fn level_filter_event_with_target_and_span_global() { let (subscriber, handle) = subscriber::mock() .enter(cool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) .exit(cool_span) .enter(uncool_span.clone()) .exit(uncool_span) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -133,12 +133,12 @@ fn not_order_dependent() { let filter: EnvFilter = "stuff=debug,info".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::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 = subscriber.with(filter); @@ -167,9 +167,9 @@ fn add_directive_enables_event() { filter = filter.add_directive("hello=trace".parse().expect("directive should parse")); let (subscriber, finished) = subscriber::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 = subscriber.with(filter); @@ -187,19 +187,19 @@ fn span_name_filter_is_dynamic() { .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) - .enter(span::named("cool_span")) - .event(event::mock().at_level(Level::DEBUG)) - .enter(span::named("uncool_span")) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::DEBUG)) - .exit(span::named("uncool_span")) - .exit(span::named("cool_span")) - .enter(span::named("uncool_span")) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .exit(span::named("uncool_span")) - .done() + .event(event::expect().at_level(Level::INFO)) + .enter(span::expect().named("cool_span")) + .event(event::expect().at_level(Level::DEBUG)) + .enter(span::expect().named("uncool_span")) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::DEBUG)) + .exit(span::expect().named("uncool_span")) + .exit(span::expect().named("cool_span")) + .enter(span::expect().named("uncool_span")) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .exit(span::expect().named("uncool_span")) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -245,10 +245,10 @@ mod per_layer_filter { 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() @@ -271,18 +271,18 @@ mod per_layer_filter { .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() @@ -299,12 +299,12 @@ mod per_layer_filter { 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() @@ -333,12 +333,12 @@ mod per_layer_filter { 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() @@ -366,12 +366,12 @@ mod per_layer_filter { 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() @@ -401,9 +401,9 @@ mod per_layer_filter { 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() @@ -424,21 +424,21 @@ mod per_layer_filter { 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()]), ) @@ -446,17 +446,17 @@ mod per_layer_filter { .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() @@ -497,12 +497,12 @@ mod per_layer_filter { 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) }; @@ -513,12 +513,12 @@ mod per_layer_filter { 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/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/field_filter.rs b/tracing-subscriber/tests/field_filter.rs index 385d024f65..5d41ec028b 100644 --- a/tracing-subscriber/tests/field_filter.rs +++ b/tracing-subscriber/tests/field_filter.rs @@ -10,16 +10,16 @@ fn field_filter_events() { let filter: EnvFilter = "[{thing}]=debug".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .event( - event::mock() + event::expect() .at_level(Level::INFO) - .with_fields(field::mock("thing")), + .with_fields(field::expect("thing")), ) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) - .with_fields(field::mock("thing")), + .with_fields(field::expect("thing")), ) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -41,23 +41,23 @@ fn field_filter_spans() { .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .enter(span::mock().named("span1")) + .enter(span::expect().named("span1")) .event( - event::mock() + event::expect() .at_level(Level::INFO) - .with_fields(field::mock("something")), + .with_fields(field::expect("something")), ) - .exit(span::mock().named("span1")) - .enter(span::mock().named("span2")) - .exit(span::mock().named("span2")) - .enter(span::mock().named("span3")) + .exit(span::expect().named("span1")) + .enter(span::expect().named("span2")) + .exit(span::expect().named("span2")) + .enter(span::expect().named("span3")) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) - .with_fields(field::mock("something")), + .with_fields(field::expect("something")), ) - .exit(span::mock().named("span3")) - .done() + .exit(span::expect().named("span3")) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -84,16 +84,16 @@ fn record_after_created() { .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .enter(span::mock().named("span")) - .exit(span::mock().named("span")) + .enter(span::expect().named("span")) + .exit(span::expect().named("span")) .record( - span::mock().named("span"), - field::mock("enabled").with_value(&true), + span::expect().named("span"), + field::expect("enabled").with_value(&true), ) - .enter(span::mock().named("span")) - .event(event::mock().at_level(Level::DEBUG)) - .exit(span::mock().named("span")) - .done() + .enter(span::expect().named("span")) + .event(event::expect().at_level(Level::DEBUG)) + .exit(span::expect().named("span")) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); diff --git a/tracing-subscriber/tests/filter_log.rs b/tracing-subscriber/tests/filter_log.rs index 8d57ed600b..9810684e56 100644 --- a/tracing-subscriber/tests/filter_log.rs +++ b/tracing-subscriber/tests/filter_log.rs @@ -36,10 +36,10 @@ fn log_is_enabled() { .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::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(); // Note: we have to set the global default in order to set the `log` max 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/same_len_filters.rs b/tracing-subscriber/tests/same_len_filters.rs index 879e578d78..839d82e61b 100644 --- a/tracing-subscriber/tests/same_len_filters.rs +++ b/tracing-subscriber/tests/same_len_filters.rs @@ -10,9 +10,9 @@ use tracing_subscriber::{filter::EnvFilter, prelude::*}; fn same_length_targets() { let filter: EnvFilter = "foo=trace,bar=trace".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::TRACE)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::TRACE)) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -31,16 +31,16 @@ fn same_num_fields_event() { .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .event( - event::mock() + event::expect() .at_level(Level::TRACE) - .with_fields(field::mock("foo")), + .with_fields(field::expect("foo")), ) .event( - event::mock() + event::expect() .at_level(Level::TRACE) - .with_fields(field::mock("bar")), + .with_fields(field::expect("bar")), ) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); with_default(subscriber, || { @@ -58,18 +58,18 @@ fn same_num_fields_and_name_len() { .expect("filter should parse"); let (subscriber, finished) = subscriber::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("baz") .at_level(Level::TRACE) - .with_field(field::mock("boz")), + .with_field(field::expect("boz")), ) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); with_default(subscriber, || { 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-subscriber/tests/utils.rs b/tracing-subscriber/tests/utils.rs index e95868d5ea..6cf96b066e 100644 --- a/tracing-subscriber/tests/utils.rs +++ b/tracing-subscriber/tests/utils.rs @@ -7,11 +7,11 @@ use tracing_subscriber::prelude::*; fn init_ext_works() { let (subscriber, finished) = subscriber::mock() .event( - event::mock() + event::expect() .at_level(tracing::Level::INFO) .with_target("init_works"), ) - .done() + .only() .run_with_handle(); let _guard = subscriber.set_default(); diff --git a/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs b/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs index 1bfb4a0adf..9a9f117cdd 100644 --- a/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs +++ b/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs @@ -4,14 +4,11 @@ use std::{ sync::{Arc, Mutex}, }; use tracing::{Level, Subscriber}; -use tracing_mock::{ - event, - layer::{self, MockLayer}, -}; +use tracing_mock::{layer::MockLayer, *}; use tracing_subscriber::{filter, prelude::*}; #[test] -fn vec_layer_filter_interests_are_cached() { +fn vec_subscriber_filter_interests_are_cached() { let mk_filtered = |level: Level, subscriber: MockLayer| { let seen = Arc::new(Mutex::new(HashMap::new())); let filter = filter::filter_fn({ @@ -26,23 +23,23 @@ fn vec_layer_filter_interests_are_cached() { // This layer will return Interest::always for INFO and lower. 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, seen_info) = mk_filtered(Level::INFO, info_layer); // This layer will return Interest::always for WARN and lower. 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, seen_warn) = mk_filtered(Level::WARN, warn_layer); diff --git a/tracing/tests/enabled.rs b/tracing/tests/enabled.rs index ea1c69804d..5a4596347e 100644 --- a/tracing/tests/enabled.rs +++ b/tracing/tests/enabled.rs @@ -13,7 +13,7 @@ fn level_and_target() { meta.level() <= &Level::INFO } }) - .done() + .only() .run(); let _guard = tracing::subscriber::set_default(subscriber); @@ -38,7 +38,7 @@ fn span_and_event() { meta.level() <= &Level::INFO } }) - .done() + .only() .run(); let _guard = tracing::subscriber::set_default(subscriber); diff --git a/tracing/tests/event.rs b/tracing/tests/event.rs index 61df19ad3c..6e943c60db 100644 --- a/tracing/tests/event.rs +++ b/tracing/tests/event.rs @@ -22,17 +22,17 @@ macro_rules! event_without_message { fn $name() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("answer") + event::expect().with_fields( + field::expect("answer") .with_value(&42) .and( - field::mock("to_question") + field::expect("to_question") .with_value(&"life, the universe, and everything"), ) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -57,15 +57,19 @@ event_without_message! {nonzeroi32_event_without_message: std::num::NonZeroI32:: #[test] fn event_with_message() { let (subscriber, handle) = subscriber::mock() - .event(event::msg(format_args!( - "hello from my event! yak shaved = {:?}", - true - ))) - .done() + .event( + event::expect().with_fields(field::expect("message").with_value( + &tracing::field::debug(format_args!( + "hello from my tracing::event! yak shaved = {:?}", + true + )), + )), + ) + .only() .run_with_handle(); with_default(subscriber, || { - debug!("hello from my event! yak shaved = {:?}", true); + debug!("hello from my tracing::event! yak shaved = {:?}", true); }); handle.assert_finished(); @@ -76,10 +80,12 @@ fn event_with_message() { fn message_without_delims() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("answer") + event::expect().with_fields( + field::expect("answer") .with_value(&42) - .and(field::mock("question").with_value(&"life, the universe, and everything")) + .and( + field::expect("question").with_value(&"life, the universe, and everything"), + ) .and(field::msg(format_args!( "hello from my event! tricky? {:?}!", true @@ -87,7 +93,7 @@ fn message_without_delims() { .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -103,15 +109,17 @@ fn message_without_delims() { fn string_message_without_delims() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("answer") + event::expect().with_fields( + field::expect("answer") .with_value(&42) - .and(field::mock("question").with_value(&"life, the universe, and everything")) + .and( + field::expect("question").with_value(&"life, the universe, and everything"), + ) .and(field::msg(format_args!("hello from my event"))) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -127,23 +135,23 @@ fn string_message_without_delims() { fn one_with_everything() { let (subscriber, handle) = subscriber::mock() .event( - event::mock() + event::expect() .with_fields( - field::mock("message") + field::expect("message") .with_value(&tracing::field::debug(format_args!( "{:#x} make me one with{what:.>20}", 4_277_009_102u64, what = "everything" ))) - .and(field::mock("foo").with_value(&666)) - .and(field::mock("bar").with_value(&false)) - .and(field::mock("like_a_butterfly").with_value(&42.0)) + .and(field::expect("foo").with_value(&666)) + .and(field::expect("bar").with_value(&false)) + .and(field::expect("like_a_butterfly").with_value(&42.0)) .only(), ) .at_level(Level::ERROR) .with_target("whatever"), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -163,13 +171,13 @@ fn one_with_everything() { fn moved_field() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("foo") + event::expect().with_fields( + field::expect("foo") .with_value(&display("hello from my event")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { let from = "my event"; @@ -184,14 +192,14 @@ fn moved_field() { fn dotted_field_name() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("foo.bar") + event::expect().with_fields( + field::expect("foo.bar") .with_value(&true) - .and(field::mock("foo.baz").with_value(&false)) + .and(field::expect("foo.baz").with_value(&false)) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { tracing::event!(Level::INFO, foo.bar = true, foo.baz = false); @@ -205,13 +213,13 @@ fn dotted_field_name() { fn borrowed_field() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("foo") + event::expect().with_fields( + field::expect("foo") .with_value(&display("hello from my event")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { let from = "my event"; @@ -242,15 +250,15 @@ fn move_field_out_of_struct() { }; let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("x") + event::expect().with_fields( + field::expect("x") .with_value(&debug(3.234)) - .and(field::mock("y").with_value(&debug(-1.223))) + .and(field::expect("y").with_value(&debug(-1.223))) .only(), ), ) - .event(event::mock().with_fields(field::mock("position").with_value(&debug(&pos)))) - .done() + .event(event::expect().with_fields(field::expect("position").with_value(&debug(&pos)))) + .only() .run_with_handle(); with_default(subscriber, || { @@ -269,13 +277,13 @@ fn move_field_out_of_struct() { fn display_shorthand() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("my_field") + event::expect().with_fields( + field::expect("my_field") .with_value(&display("hello world")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { tracing::event!(Level::TRACE, my_field = %"hello world"); @@ -289,13 +297,13 @@ fn display_shorthand() { fn debug_shorthand() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("my_field") + event::expect().with_fields( + field::expect("my_field") .with_value(&debug("hello world")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { tracing::event!(Level::TRACE, my_field = ?"hello world"); @@ -309,14 +317,14 @@ fn debug_shorthand() { fn both_shorthands() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("display_field") + event::expect().with_fields( + field::expect("display_field") .with_value(&display("hello world")) - .and(field::mock("debug_field").with_value(&debug("hello world"))) + .and(field::expect("debug_field").with_value(&debug("hello world"))) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { tracing::event!(Level::TRACE, display_field = %"hello world", debug_field = ?"hello world"); @@ -329,9 +337,9 @@ fn both_shorthands() { #[test] fn explicit_child() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo")) - .event(event::mock().with_explicit_parent(Some("foo"))) - .done() + .new_span(span::expect().named("foo")) + .event(event::expect().with_explicit_parent(Some("foo"))) + .only() .run_with_handle(); with_default(subscriber, || { @@ -346,13 +354,13 @@ fn explicit_child() { #[test] fn explicit_child_at_levels() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo")) - .event(event::mock().with_explicit_parent(Some("foo"))) - .event(event::mock().with_explicit_parent(Some("foo"))) - .event(event::mock().with_explicit_parent(Some("foo"))) - .event(event::mock().with_explicit_parent(Some("foo"))) - .event(event::mock().with_explicit_parent(Some("foo"))) - .done() + .new_span(span::expect().named("foo")) + .event(event::expect().with_explicit_parent(Some("foo"))) + .event(event::expect().with_explicit_parent(Some("foo"))) + .event(event::expect().with_explicit_parent(Some("foo"))) + .event(event::expect().with_explicit_parent(Some("foo"))) + .event(event::expect().with_explicit_parent(Some("foo"))) + .only() .run_with_handle(); with_default(subscriber, || { @@ -372,15 +380,15 @@ fn explicit_child_at_levels() { fn option_values() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("some_str") + event::expect().with_fields( + field::expect("some_str") .with_value(&"yes") - .and(field::mock("some_bool").with_value(&true)) - .and(field::mock("some_u64").with_value(&42_u64)) + .and(field::expect("some_bool").with_value(&true)) + .and(field::expect("some_u64").with_value(&42_u64)) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -408,15 +416,15 @@ fn option_values() { fn option_ref_values() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("some_str") + event::expect().with_fields( + field::expect("some_str") .with_value(&"yes") - .and(field::mock("some_bool").with_value(&true)) - .and(field::mock("some_u64").with_value(&42_u64)) + .and(field::expect("some_bool").with_value(&true)) + .and(field::expect("some_u64").with_value(&42_u64)) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -444,15 +452,15 @@ fn option_ref_values() { fn option_ref_mut_values() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("some_str") + event::expect().with_fields( + field::expect("some_str") .with_value(&"yes") - .and(field::mock("some_bool").with_value(&true)) - .and(field::mock("some_u64").with_value(&42_u64)) + .and(field::expect("some_bool").with_value(&true)) + .and(field::expect("some_u64").with_value(&42_u64)) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -479,11 +487,15 @@ fn option_ref_mut_values() { #[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/filters_dont_leak.rs b/tracing/tests/filters_dont_leak.rs index 2ef1c9c701..df96a4ac72 100644 --- a/tracing/tests/filters_dont_leak.rs +++ b/tracing/tests/filters_dont_leak.rs @@ -13,14 +13,14 @@ fn spans_dont_leak() { let (subscriber, handle) = subscriber::mock() .named("spans/subscriber1") .with_filter(|_| false) - .done() + .only() .run_with_handle(); let _guard = tracing::subscriber::set_default(subscriber); do_span(); - let alice = span::mock().named("alice"); + let alice = span::expect().named("alice"); let (subscriber2, handle2) = subscriber::mock() .named("spans/subscriber2") .with_filter(|_| true) @@ -28,7 +28,7 @@ fn spans_dont_leak() { .enter(alice.clone()) .exit(alice.clone()) .drop_span(alice) - .done() + .only() .run_with_handle(); tracing::subscriber::with_default(subscriber2, || { @@ -53,7 +53,7 @@ fn events_dont_leak() { let (subscriber, handle) = subscriber::mock() .named("events/subscriber1") .with_filter(|_| false) - .done() + .only() .run_with_handle(); let _guard = tracing::subscriber::set_default(subscriber); @@ -63,8 +63,8 @@ fn events_dont_leak() { let (subscriber2, handle2) = subscriber::mock() .named("events/subscriber2") .with_filter(|_| true) - .event(event::mock()) - .done() + .event(event::expect()) + .only() .run_with_handle(); tracing::subscriber::with_default(subscriber2, || { diff --git a/tracing/tests/instrument.rs b/tracing/tests/instrument.rs index a23769e66f..07b6bbfa42 100644 --- a/tracing/tests/instrument.rs +++ b/tracing/tests/instrument.rs @@ -33,17 +33,17 @@ fn span_on_drop() { } let subscriber = subscriber::mock() - .enter(span::mock().named("foo")) - .event(event::mock().at_level(Level::INFO)) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .enter(span::mock().named("bar")) - .event(event::mock().at_level(Level::INFO)) - .exit(span::mock().named("bar")) - .drop_span(span::mock().named("bar")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect().at_level(Level::INFO)) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .enter(span::expect().named("bar")) + .event(event::expect().at_level(Level::INFO)) + .exit(span::expect().named("bar")) + .drop_span(span::expect().named("bar")) + .only() .run(); with_default(subscriber, || { diff --git a/tracing/tests/max_level_hint.rs b/tracing/tests/max_level_hint.rs index 63d3af6357..5c7c476bf3 100644 --- a/tracing/tests/max_level_hint.rs +++ b/tracing/tests/max_level_hint.rs @@ -20,10 +20,10 @@ fn max_level_hints() { ); true }) - .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(); tracing::subscriber::set_global_default(subscriber).unwrap(); diff --git a/tracing/tests/multiple_max_level_hints.rs b/tracing/tests/multiple_max_level_hints.rs index dd50a193b5..81cc8052e9 100644 --- a/tracing/tests/multiple_max_level_hints.rs +++ b/tracing/tests/multiple_max_level_hints.rs @@ -35,10 +35,10 @@ fn multiple_max_level_hints() { ); level <= &Level::INFO }) - .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 (subscriber2, handle2) = subscriber::mock() .named("subscriber2") @@ -51,11 +51,11 @@ fn multiple_max_level_hints() { ); level <= &Level::DEBUG }) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG)) - .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::DEBUG)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let dispatch1 = tracing::Dispatch::new(subscriber1); 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 e4e17757eb..40ba193da8 100644 --- a/tracing/tests/span.rs +++ b/tracing/tests/span.rs @@ -67,12 +67,12 @@ fn handles_to_different_spans_with_the_same_metadata_are_not_equal() { #[test] fn spans_always_go_to_the_subscriber_that_tagged_them() { let subscriber1 = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .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")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run(); let subscriber2 = subscriber::mock().run(); @@ -94,12 +94,12 @@ fn spans_always_go_to_the_subscriber_that_tagged_them() { #[test] fn spans_always_go_to_the_subscriber_that_tagged_them_even_across_threads() { let subscriber1 = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .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")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run(); let foo = with_default(subscriber1, || { let foo = tracing::span!(Level::TRACE, "foo"); @@ -122,10 +122,10 @@ fn spans_always_go_to_the_subscriber_that_tagged_them_even_across_threads() { #[test] fn dropping_a_span_calls_drop_span() { let (subscriber, handle) = subscriber::mock() - .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(); with_default(subscriber, || { let span = tracing::span!(Level::TRACE, "foo"); @@ -140,11 +140,11 @@ fn dropping_a_span_calls_drop_span() { #[test] fn span_closes_after_event() { 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, || { tracing::span!(Level::TRACE, "foo").in_scope(|| { @@ -159,14 +159,14 @@ fn span_closes_after_event() { #[test] fn new_span_after_event() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .event(event::mock()) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .enter(span::mock().named("bar")) - .exit(span::mock().named("bar")) - .drop_span(span::mock().named("bar")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect()) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .enter(span::expect().named("bar")) + .exit(span::expect().named("bar")) + .drop_span(span::expect().named("bar")) + .only() .run_with_handle(); with_default(subscriber, || { tracing::span!(Level::TRACE, "foo").in_scope(|| { @@ -182,11 +182,11 @@ fn new_span_after_event() { #[test] fn event_outside_of_span() { let (subscriber, handle) = subscriber::mock() - .event(event::mock()) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .event(event::expect()) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { tracing::debug!("my tracing::event!"); @@ -200,7 +200,7 @@ fn event_outside_of_span() { #[test] fn cloning_a_span_calls_clone_span() { let (subscriber, handle) = subscriber::mock() - .clone_span(span::mock().named("foo")) + .clone_span(span::expect().named("foo")) .run_with_handle(); with_default(subscriber, || { let span = tracing::span!(Level::TRACE, "foo"); @@ -216,9 +216,9 @@ fn cloning_a_span_calls_clone_span() { #[test] fn drop_span_when_exiting_dispatchers_context() { let (subscriber, handle) = subscriber::mock() - .clone_span(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) + .clone_span(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .run_with_handle(); with_default(subscriber, || { let span = tracing::span!(Level::TRACE, "foo"); @@ -233,15 +233,15 @@ fn drop_span_when_exiting_dispatchers_context() { #[test] fn clone_and_drop_span_always_go_to_the_subscriber_that_tagged_the_span() { let (subscriber1, handle1) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .clone_span(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .clone_span(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .run_with_handle(); - let subscriber2 = subscriber::mock().done().run(); + let subscriber2 = subscriber::mock().only().run(); let foo = with_default(subscriber1, || { let foo = tracing::span!(Level::TRACE, "foo"); @@ -264,10 +264,10 @@ fn clone_and_drop_span_always_go_to_the_subscriber_that_tagged_the_span() { #[test] fn span_closes_when_exited() { let (subscriber, handle) = subscriber::mock() - .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(); with_default(subscriber, || { let foo = tracing::span!(Level::TRACE, "foo"); @@ -284,11 +284,11 @@ fn span_closes_when_exited() { #[test] fn enter() { 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 foo = tracing::span!(Level::TRACE, "foo"); @@ -303,11 +303,11 @@ fn enter() { #[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(); @@ -321,11 +321,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(); @@ -342,16 +342,16 @@ fn entered_api() { fn moved_field() { 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(); with_default(subscriber, || { let from = "my span"; @@ -371,11 +371,11 @@ fn moved_field() { fn dotted_field_name() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock() + span::expect() .named("foo") - .with_field(field::mock("fields.bar").with_value(&true).only()), + .with_field(field::expect("fields.bar").with_value(&true).only()), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { tracing::span!(Level::TRACE, "foo", fields.bar = true); @@ -389,16 +389,16 @@ fn dotted_field_name() { fn borrowed_field() { 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(); with_default(subscriber, || { @@ -432,17 +432,17 @@ fn move_field_out_of_struct() { }; let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("x") + span::expect().named("foo").with_field( + field::expect("x") .with_value(&debug(3.234)) - .and(field::mock("y").with_value(&debug(-1.223))) + .and(field::expect("y").with_value(&debug(-1.223))) .only(), ), ) .new_span( - span::mock() + span::expect() .named("bar") - .with_field(field::mock("position").with_value(&debug(&pos)).only()), + .with_field(field::expect("position").with_value(&debug(&pos)).only()), ) .run_with_handle(); @@ -465,10 +465,10 @@ fn move_field_out_of_struct() { fn float_values() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("x") + span::expect().named("foo").with_field( + field::expect("x") .with_value(&3.234) - .and(field::mock("y").with_value(&-1.223)) + .and(field::expect("y").with_value(&-1.223)) .only(), ), ) @@ -490,19 +490,19 @@ fn float_values() { fn add_field_after_new_span() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock() + span::expect() .named("foo") - .with_field(field::mock("bar").with_value(&5) - .and(field::mock("baz").with_value).only()), + .with_field(field::expect("bar").with_value(&5) + .and(field::expect("baz").with_value).only()), ) .record( - span::mock().named("foo"), - field::mock("baz").with_value(&true).only(), + span::expect().named("foo"), + field::expect("baz").with_value(&true).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(); with_default(subscriber, || { @@ -518,19 +518,19 @@ fn add_field_after_new_span() { #[test] fn add_fields_only_after_new_span() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo")) + .new_span(span::expect().named("foo")) .record( - span::mock().named("foo"), - field::mock("bar").with_value(&5).only(), + span::expect().named("foo"), + field::expect("bar").with_value(&5).only(), ) .record( - span::mock().named("foo"), - field::mock("baz").with_value(&true).only(), + span::expect().named("foo"), + field::expect("baz").with_value(&true).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(); with_default(subscriber, || { @@ -549,21 +549,21 @@ fn add_fields_only_after_new_span() { fn record_new_value_for_field() { 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(&5) - .and(field::mock("baz").with_value(&false)) + .and(field::expect("baz").with_value(&false)) .only(), ), ) .record( - span::mock().named("foo"), - field::mock("baz").with_value(&true).only(), + span::expect().named("foo"), + field::expect("baz").with_value(&true).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(); with_default(subscriber, || { @@ -580,25 +580,25 @@ fn record_new_value_for_field() { fn record_new_values_for_fields() { 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(&4) - .and(field::mock("baz").with_value(&false)) + .and(field::expect("baz").with_value(&false)) .only(), ), ) .record( - span::mock().named("foo"), - field::mock("bar").with_value(&5).only(), + span::expect().named("foo"), + field::expect("bar").with_value(&5).only(), ) .record( - span::mock().named("foo"), - field::mock("baz").with_value(&true).only(), + span::expect().named("foo"), + field::expect("baz").with_value(&true).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(); with_default(subscriber, || { @@ -616,12 +616,12 @@ fn record_new_values_for_fields() { fn new_span_with_target_and_log_level() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock() + span::expect() .named("foo") .with_target("app_span") .at_level(Level::DEBUG), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -635,8 +635,8 @@ fn new_span_with_target_and_log_level() { #[test] fn explicit_root_span_is_root() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo").with_explicit_parent(None)) - .done() + .new_span(span::expect().named("foo").with_explicit_parent(None)) + .only() .run_with_handle(); with_default(subscriber, || { @@ -650,11 +650,11 @@ fn explicit_root_span_is_root() { #[test] fn explicit_root_span_is_root_regardless_of_ctx() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .new_span(span::mock().named("bar").with_explicit_parent(None)) - .exit(span::mock().named("foo")) - .done() + .new_span(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .new_span(span::expect().named("bar").with_explicit_parent(None)) + .exit(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { @@ -670,9 +670,13 @@ fn explicit_root_span_is_root_regardless_of_ctx() { #[test] fn explicit_child() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo")) - .new_span(span::mock().named("bar").with_explicit_parent(Some("foo"))) - .done() + .new_span(span::expect().named("foo")) + .new_span( + span::expect() + .named("bar") + .with_explicit_parent(Some("foo")), + ) + .only() .run_with_handle(); with_default(subscriber, || { @@ -687,13 +691,13 @@ fn explicit_child() { #[test] fn explicit_child_at_levels() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo")) - .new_span(span::mock().named("a").with_explicit_parent(Some("foo"))) - .new_span(span::mock().named("b").with_explicit_parent(Some("foo"))) - .new_span(span::mock().named("c").with_explicit_parent(Some("foo"))) - .new_span(span::mock().named("d").with_explicit_parent(Some("foo"))) - .new_span(span::mock().named("e").with_explicit_parent(Some("foo"))) - .done() + .new_span(span::expect().named("foo")) + .new_span(span::expect().named("a").with_explicit_parent(Some("foo"))) + .new_span(span::expect().named("b").with_explicit_parent(Some("foo"))) + .new_span(span::expect().named("c").with_explicit_parent(Some("foo"))) + .new_span(span::expect().named("d").with_explicit_parent(Some("foo"))) + .new_span(span::expect().named("e").with_explicit_parent(Some("foo"))) + .only() .run_with_handle(); with_default(subscriber, || { @@ -712,12 +716,16 @@ fn explicit_child_at_levels() { #[test] fn explicit_child_regardless_of_ctx() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo")) - .new_span(span::mock().named("bar")) - .enter(span::mock().named("bar")) - .new_span(span::mock().named("baz").with_explicit_parent(Some("foo"))) - .exit(span::mock().named("bar")) - .done() + .new_span(span::expect().named("foo")) + .new_span(span::expect().named("bar")) + .enter(span::expect().named("bar")) + .new_span( + span::expect() + .named("baz") + .with_explicit_parent(Some("foo")), + ) + .exit(span::expect().named("bar")) + .only() .run_with_handle(); with_default(subscriber, || { @@ -733,8 +741,8 @@ fn explicit_child_regardless_of_ctx() { #[test] fn contextual_root() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo").with_contextual_parent(None)) - .done() + .new_span(span::expect().named("foo").with_contextual_parent(None)) + .only() .run_with_handle(); with_default(subscriber, || { @@ -748,15 +756,15 @@ fn contextual_root() { #[test] fn contextual_child() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo")) - .enter(span::mock().named("foo")) + .new_span(span::expect().named("foo")) + .enter(span::expect().named("foo")) .new_span( - span::mock() + span::expect() .named("bar") .with_contextual_parent(Some("foo")), ) - .exit(span::mock().named("foo")) - .done() + .exit(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { @@ -773,13 +781,13 @@ fn contextual_child() { fn display_shorthand() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("my_span").with_field( - field::mock("my_field") + span::expect().named("my_span").with_field( + field::expect("my_field") .with_value(&display("hello world")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { tracing::span!(Level::TRACE, "my_span", my_field = %"hello world"); @@ -793,13 +801,13 @@ fn display_shorthand() { fn debug_shorthand() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("my_span").with_field( - field::mock("my_field") + span::expect().named("my_span").with_field( + field::expect("my_field") .with_value(&debug("hello world")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { tracing::span!(Level::TRACE, "my_span", my_field = ?"hello world"); @@ -813,14 +821,14 @@ fn debug_shorthand() { fn both_shorthands() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("my_span").with_field( - field::mock("display_field") + span::expect().named("my_span").with_field( + field::expect("display_field") .with_value(&display("hello world")) - .and(field::mock("debug_field").with_value(&debug("hello world"))) + .and(field::expect("debug_field").with_value(&debug("hello world"))) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { tracing::span!(Level::TRACE, "my_span", display_field = %"hello world", debug_field = ?"hello world"); 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);