From 5197803f23355fc8c0ce40790643e3a950919990 Mon Sep 17 00:00:00 2001 From: Hayden Stainsby Date: Fri, 11 Nov 2022 18:53:06 +0100 Subject: [PATCH] mock: change helper functions to `expect::` (#2377) * mock: change helper functions to `expect::` The current format of test expectations in `tracing-mock` isn't ideal. The format `span::expect` requires importing `tracing_mock::` which may conflict with imports from other tracing crates, especially `tracing-core`. So we change the order and move the functions into a module called `expect` so that: * `event::expect` becomes `expect::event` * `span::expect` becomes `expect::span` * `field::expect` becomes `expect::field` This format has two advantages. 1. It reads as natural English, e.g "expect span" 2. It is no longer common to import the modules directly. Regarding point (2), the following format was previously common: ```rust use tracing_mock::field; field::expect(); ``` This import of the `field` module may then conflict with importing the same from `tracing_core`, making it necessary to rename one of the imports. The same code would now be written: ```rust use tracing_mock::expect; expect::field(); ``` Which is less likely to conflict. This change also fixes an unused warning on `MockHandle::new` when the `tracing-subscriber` feature is not enabled. Refs: #539 --- tracing-attributes/tests/async_fn.rs | 76 ++--- tracing-attributes/tests/destructuring.rs | 42 +-- tracing-attributes/tests/err.rs | 62 ++-- tracing-attributes/tests/fields.rs | 51 ++-- tracing-attributes/tests/follows_from.rs | 20 +- tracing-attributes/tests/instrument.rs | 42 +-- tracing-attributes/tests/levels.rs | 90 +++--- tracing-attributes/tests/names.rs | 18 +- tracing-attributes/tests/parents.rs | 10 +- tracing-attributes/tests/ret.rs | 70 ++--- tracing-attributes/tests/targets.rs | 24 +- tracing-futures/src/lib.rs | 98 +++---- tracing-futures/tests/std_future.rs | 48 ++-- tracing-mock/src/event.rs | 18 +- .../src/{expectation.rs => expect.rs} | 24 +- tracing-mock/src/field.rs | 14 +- tracing-mock/src/layer.rs | 2 +- tracing-mock/src/lib.rs | 2 +- tracing-mock/src/span.rs | 10 +- tracing-mock/src/subscriber.rs | 2 +- ...d_layer_filters_dont_break_other_layers.rs | 18 +- tracing-subscriber/tests/env_filter/main.rs | 122 ++++---- .../tests/env_filter/per_layer.rs | 58 ++-- tracing-subscriber/tests/field_filter.rs | 42 +-- tracing-subscriber/tests/filter_log.rs | 6 +- ...d_layer_filters_dont_break_other_layers.rs | 18 +- .../layer_filter_interests_are_cached.rs | 6 +- .../tests/layer_filters/filter_scopes.rs | 84 +++--- .../tests/layer_filters/main.rs | 42 +-- .../tests/layer_filters/per_event.rs | 6 +- .../tests/layer_filters/targets.rs | 1 + .../tests/layer_filters/trees.rs | 58 ++-- tracing-subscriber/tests/layer_filters/vec.rs | 26 +- .../multiple_layer_filter_interests_cached.rs | 22 +- tracing-subscriber/tests/same_len_filters.rs | 20 +- ...d_layer_filters_dont_break_other_layers.rs | 18 +- tracing-subscriber/tests/utils.rs | 2 +- .../vec_subscriber_filter_interests_cached.rs | 20 +- tracing/tests/event.rs | 112 ++++---- tracing/tests/filters_dont_leak.rs | 4 +- tracing/tests/instrument.rs | 20 +- tracing/tests/max_level_hint.rs | 6 +- tracing/tests/multiple_max_level_hints.rs | 14 +- tracing/tests/span.rs | 272 +++++++++--------- tracing/tests/subscriber.rs | 27 +- 45 files changed, 873 insertions(+), 874 deletions(-) rename tracing-mock/src/{expectation.rs => expect.rs} (51%) diff --git a/tracing-attributes/tests/async_fn.rs b/tracing-attributes/tests/async_fn.rs index 924d46bed6..ed36d0d6fb 100644 --- a/tracing-attributes/tests/async_fn.rs +++ b/tracing-attributes/tests/async_fn.rs @@ -84,15 +84,15 @@ fn repro_1831_2() -> impl Future> { #[test] fn async_fn_only_enters_for_polls() { let (subscriber, handle) = subscriber::mock() - .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")) + .new_span(expect::span().named("test_async_fn")) + .enter(expect::span().named("test_async_fn")) + .event(expect::event().with_fields(expect::field("awaiting").with_value(&true))) + .exit(expect::span().named("test_async_fn")) + .enter(expect::span().named("test_async_fn")) + .exit(expect::span().named("test_async_fn")) + .enter(expect::span().named("test_async_fn")) + .exit(expect::span().named("test_async_fn")) + .drop_span(expect::span().named("test_async_fn")) .only() .run_with_handle(); with_default(subscriber, || { @@ -113,14 +113,14 @@ fn async_fn_nested() { tracing::trace!(nested = true); } - let span = span::expect().named("test_async_fns_nested"); - let span2 = span::expect().named("test_async_fns_nested_other"); + let span = expect::span().named("test_async_fns_nested"); + let span2 = expect::span().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::expect().with_fields(field::expect("nested").with_value(&true))) + .event(expect::event().with_fields(expect::field("nested").with_value(&true))) .exit(span2.clone()) .enter(span2.clone()) .exit(span2.clone()) @@ -191,26 +191,26 @@ fn async_fn_with_async_trait() { } } - let span = span::expect().named("foo"); - let span2 = span::expect().named("bar"); - let span3 = span::expect().named("baz"); + let span = expect::span().named("foo"); + let span2 = expect::span().named("bar"); + let span3 = expect::span().named("baz"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::expect("self")) - .with_field(field::expect("v")), + .with_field(expect::field("self")) + .with_field(expect::field("v")), ) .enter(span.clone()) .new_span(span3.clone()) .enter(span3.clone()) - .event(event::expect().with_fields(field::expect("val").with_value(&2u64))) + .event(expect::event().with_fields(expect::field("val").with_value(&2u64))) .exit(span3.clone()) .enter(span3.clone()) .exit(span3.clone()) .drop_span(span3) - .new_span(span2.clone().with_field(field::expect("self"))) + .new_span(span2.clone().with_field(expect::field("self"))) .enter(span2.clone()) - .event(event::expect().with_fields(field::expect("val").with_value(&5u64))) + .event(expect::event().with_fields(expect::field("val").with_value(&5u64))) .exit(span2.clone()) .enter(span2.clone()) .exit(span2.clone()) @@ -255,15 +255,15 @@ fn async_fn_with_async_trait_and_fields_expressions() { async fn call(&mut self, _v: usize) {} } - let span = span::expect().named("call"); + let span = expect::span().named("call"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("_v") + expect::field("_v") .with_value(&5usize) - .and(field::expect("test").with_value(&tracing::field::debug(10))) - .and(field::expect("val").with_value(&42u64)) - .and(field::expect("val2").with_value(&42u64)), + .and(expect::field("test").with_value(&tracing::field::debug(10))) + .and(expect::field("val").with_value(&42u64)) + .and(expect::field("val2").with_value(&42u64)), ), ) .enter(span.clone()) @@ -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::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 span = span::mock().named("call"); + let span2 = expect::span().named("call_with_self"); + let span3 = expect::span().named("call_with_mut_self"); + let span4 = expect::span().named("sync_fun"); let (subscriber, handle) = subscriber::mock() /*.new_span(span.clone() .with_field( - field::expect("Self").with_value(&"TestImpler"))) + expect::field("Self").with_value(&"TestImpler"))) .enter(span.clone()) .exit(span.clone()) .drop_span(span)*/ .new_span( span2 .clone() - .with_field(field::expect("Self").with_value(&std::any::type_name::())), + .with_field(expect::field("Self").with_value(&std::any::type_name::())), ) .enter(span2.clone()) .new_span( span4 .clone() - .with_field(field::expect("Self").with_value(&std::any::type_name::())), + .with_field(expect::field("Self").with_value(&std::any::type_name::())), ) .enter(span4.clone()) .exit(span4.clone()) @@ -355,7 +355,7 @@ fn async_fn_with_async_trait_and_fields_expressions_with_generic_parameter() { .new_span( span3 .clone() - .with_field(field::expect("Self").with_value(&std::any::type_name::())), + .with_field(expect::field("Self").with_value(&std::any::type_name::())), ) .enter(span3.clone()) .exit(span3.clone()) @@ -397,7 +397,7 @@ fn out_of_scope_fields() { } } - let span = span::expect().named("call"); + let span = expect::span().named("call"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) @@ -430,8 +430,8 @@ fn manual_impl_future() { } } - let span = span::expect().named("manual_impl_future"); - let poll_event = || event::expect().with_fields(field::expect("poll").with_value(&true)); + let span = expect::span().named("manual_impl_future"); + let poll_event = || expect::event().with_fields(expect::field("poll").with_value(&true)); let (subscriber, handle) = subscriber::mock() // await manual_impl_future @@ -463,8 +463,8 @@ fn manual_box_pin() { }) } - let span = span::expect().named("manual_box_pin"); - let poll_event = || event::expect().with_fields(field::expect("poll").with_value(&true)); + let span = expect::span().named("manual_box_pin"); + let poll_event = || expect::event().with_fields(expect::field("poll").with_value(&true)); let (subscriber, handle) = subscriber::mock() // await manual_box_pin diff --git a/tracing-attributes/tests/destructuring.rs b/tracing-attributes/tests/destructuring.rs index 6adbe501c3..cc4fecf3f2 100644 --- a/tracing-attributes/tests/destructuring.rs +++ b/tracing-attributes/tests/destructuring.rs @@ -7,14 +7,14 @@ fn destructure_tuples() { #[instrument] fn my_fn((arg1, arg2): (usize, usize)) {} - let span = span::expect().named("my_fn"); + let span = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("arg1") + expect::field("arg1") .with_value(&format_args!("1")) - .and(field::expect("arg2").with_value(&format_args!("2"))) + .and(expect::field("arg2").with_value(&format_args!("2"))) .only(), ), ) @@ -36,16 +36,16 @@ fn destructure_nested_tuples() { #[instrument] fn my_fn(((arg1, arg2), (arg3, arg4)): ((usize, usize), (usize, usize))) {} - let span = span::expect().named("my_fn"); + let span = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("arg1") + expect::field("arg1") .with_value(&format_args!("1")) - .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"))) + .and(expect::field("arg2").with_value(&format_args!("2"))) + .and(expect::field("arg3").with_value(&format_args!("3"))) + .and(expect::field("arg4").with_value(&format_args!("4"))) .only(), ), ) @@ -67,12 +67,12 @@ fn destructure_refs() { #[instrument] fn my_fn(&arg1: &usize) {} - let span = span::expect().named("my_fn"); + let span = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::expect("arg1").with_value(&1usize).only()), + .with_field(expect::field("arg1").with_value(&1usize).only()), ) .enter(span.clone()) .exit(span.clone()) @@ -94,14 +94,14 @@ fn destructure_tuple_structs() { #[instrument] fn my_fn(Foo(arg1, arg2): Foo) {} - let span = span::expect().named("my_fn"); + let span = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("arg1") + expect::field("arg1") .with_value(&format_args!("1")) - .and(field::expect("arg2").with_value(&format_args!("2"))) + .and(expect::field("arg2").with_value(&format_args!("2"))) .only(), ), ) @@ -135,14 +135,14 @@ fn destructure_structs() { let _ = (arg1, arg2); } - let span = span::expect().named("my_fn"); + let span = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("arg1") + expect::field("arg1") .with_value(&format_args!("1")) - .and(field::expect("arg2").with_value(&format_args!("2"))) + .and(expect::field("arg2").with_value(&format_args!("2"))) .only(), ), ) @@ -180,16 +180,16 @@ fn destructure_everything() { let _ = (arg1, arg2, arg3, arg4); } - let span = span::expect().named("my_fn"); + let span = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("arg1") + expect::field("arg1") .with_value(&format_args!("1")) - .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"))) + .and(expect::field("arg2").with_value(&format_args!("2"))) + .and(expect::field("arg3").with_value(&format_args!("3"))) + .and(expect::field("arg4").with_value(&format_args!("4"))) .only(), ), ) diff --git a/tracing-attributes/tests/err.rs b/tracing-attributes/tests/err.rs index 23b28804af..bee7aa5f4e 100644 --- a/tracing-attributes/tests/err.rs +++ b/tracing-attributes/tests/err.rs @@ -21,11 +21,11 @@ fn err_suspicious_else() -> Result { #[test] fn test() { - let span = span::expect().named("err"); + let span = expect::span().named("err"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR)) .exit(span.clone()) .drop_span(span) .only() @@ -42,11 +42,11 @@ fn err_early_return() -> Result { #[test] fn test_early_return() { - let span = span::expect().named("err_early_return"); + let span = expect::span().named("err_early_return"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR)) .exit(span.clone()) .drop_span(span) .only() @@ -65,18 +65,18 @@ async fn err_async(polls: usize) -> Result { #[test] fn test_async() { - let span = span::expect().named("err_async"); + let span = expect::span().named("err_async"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("awaiting").with_value(&true)) + expect::event() + .with_fields(expect::field("awaiting").with_value(&true)) .at_level(Level::TRACE), ) .exit(span.clone()) .enter(span.clone()) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR)) .exit(span.clone()) .enter(span.clone()) .exit(span.clone()) @@ -97,11 +97,11 @@ fn err_mut(out: &mut u8) -> Result<(), TryFromIntError> { #[test] fn test_mut() { - let span = span::expect().named("err_mut"); + let span = expect::span().named("err_mut"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR)) .exit(span.clone()) .drop_span(span) .only() @@ -121,18 +121,18 @@ async fn err_mut_async(polls: usize, out: &mut u8) -> Result<(), TryFromIntError #[test] fn test_mut_async() { - let span = span::expect().named("err_mut_async"); + let span = expect::span().named("err_mut_async"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("awaiting").with_value(&true)) + expect::event() + .with_fields(expect::field("awaiting").with_value(&true)) .at_level(Level::TRACE), ) .exit(span.clone()) .enter(span.clone()) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR)) .exit(span.clone()) .enter(span.clone()) .exit(span.clone()) @@ -154,12 +154,12 @@ fn impl_trait_return_type() { Ok(0..x) } - let span = span::expect().named("returns_impl_trait"); + let span = expect::span().named("returns_impl_trait"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::expect("x").with_value(&10usize).only()), + .with_field(expect::field("x").with_value(&10usize).only()), ) .enter(span.clone()) .exit(span.clone()) @@ -183,13 +183,13 @@ fn err_dbg() -> Result { #[test] fn test_err_dbg() { - let span = span::expect().named("err_dbg"); + let span = expect::span().named("err_dbg"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect().at_level(Level::ERROR).with_fields( - field::expect("error") + expect::event().at_level(Level::ERROR).with_fields( + expect::field("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 @@ -207,13 +207,13 @@ fn test_err_dbg() { #[test] fn test_err_display_default() { - let span = span::expect().named("err"); + let span = expect::span().named("err"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect().at_level(Level::ERROR).with_fields( - field::expect("error") + expect::event().at_level(Level::ERROR).with_fields( + expect::field("error") // by default, errors will be emitted with their display values .with_value(&tracing::field::display(u8::try_from(1234).unwrap_err())), ), @@ -229,13 +229,13 @@ 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::expect().named("error_span").with_target("my_target"); + let span = expect::span().named("error_span").with_target("my_target"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() + expect::event() .at_level(Level::ERROR) .with_target("my_target"), ) @@ -264,11 +264,11 @@ fn err_info() -> Result { #[test] fn test_err_info() { - let span = span::expect().named("err_info"); + let span = expect::span().named("err_info"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) .exit(span.clone()) .drop_span(span) .only() @@ -284,13 +284,13 @@ fn err_dbg_info() -> Result { #[test] fn test_err_dbg_info() { - let span = span::expect().named("err_dbg_info"); + let span = expect::span().named("err_dbg_info"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect().at_level(Level::INFO).with_fields( - field::expect("error") + expect::event().at_level(Level::INFO).with_fields( + expect::field("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 @@ -313,11 +313,11 @@ fn err_warn_info() -> Result { #[test] fn test_err_warn_info() { - let span = span::expect().named("err_warn_info").at_level(Level::WARN); + let span = expect::span().named("err_warn_info").at_level(Level::WARN); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) .exit(span.clone()) .drop_span(span) .only() diff --git a/tracing-attributes/tests/fields.rs b/tracing-attributes/tests/fields.rs index 5911b393b7..a3b23d7ac2 100644 --- a/tracing-attributes/tests/fields.rs +++ b/tracing-attributes/tests/fields.rs @@ -1,8 +1,6 @@ use tracing::subscriber::with_default; use tracing_attributes::instrument; -use tracing_mock::field::expect; -use tracing_mock::span::NewSpan; -use tracing_mock::*; +use tracing_mock::{expect, span::NewSpan, subscriber}; #[instrument(fields(foo = "bar", dsa = true, num = 1))] fn fn_no_param() {} @@ -48,11 +46,11 @@ impl HasField { #[test] fn fields() { - let span = span::expect().with_field( - expect("foo") + let span = expect::span().with_field( + expect::field("foo") .with_value(&"bar") - .and(expect("dsa").with_value(&true)) - .and(expect("num").with_value(&1)) + .and(expect::field("dsa").with_value(&true)) + .and(expect::field("num").with_value(&1)) .only(), ); run_test(span, || { @@ -62,10 +60,10 @@ fn fields() { #[test] fn expr_field() { - let span = span::expect().with_field( - expect("s") + let span = expect::span().with_field( + expect::field("s") .with_value(&"hello world") - .and(expect("len").with_value(&"hello world".len())) + .and(expect::field("len").with_value(&"hello world".len())) .only(), ); run_test(span, || { @@ -75,11 +73,11 @@ fn expr_field() { #[test] fn two_expr_fields() { - let span = span::expect().with_field( - expect("s") + let span = expect::span().with_field( + expect::field("s") .with_value(&"hello world") - .and(expect("s.len").with_value(&"hello world".len())) - .and(expect("s.is_empty").with_value(&false)) + .and(expect::field("s.len").with_value(&"hello world".len())) + .and(expect::field("s.is_empty").with_value(&false)) .only(), ); run_test(span, || { @@ -89,19 +87,19 @@ fn two_expr_fields() { #[test] fn clashy_expr_field() { - let span = span::expect().with_field( + let span = expect::span().with_field( // Overriding the `s` field should record `s` as a `Display` value, // rather than as a `Debug` value. - expect("s") + expect::field("s") .with_value(&tracing::field::display("hello world")) - .and(expect("s.len").with_value(&"hello world".len())) + .and(expect::field("s.len").with_value(&"hello world".len())) .only(), ); run_test(span, || { fn_clashy_expr_field("hello world"); }); - let span = span::expect().with_field(expect("s").with_value(&"s").only()); + let span = expect::span().with_field(expect::field("s").with_value(&"s").only()); run_test(span, || { fn_clashy_expr_field2("hello world"); }); @@ -109,7 +107,8 @@ fn clashy_expr_field() { #[test] fn self_expr_field() { - let span = span::expect().with_field(expect("my_field").with_value(&"hello world").only()); + let span = + expect::span().with_field(expect::field("my_field").with_value(&"hello world").only()); run_test(span, || { let has_field = HasField { my_field: "hello world", @@ -120,10 +119,10 @@ fn self_expr_field() { #[test] fn parameters_with_fields() { - let span = span::expect().with_field( - expect("foo") + let span = expect::span().with_field( + expect::field("foo") .with_value(&"bar") - .and(expect("param").with_value(&1u32)) + .and(expect::field("param").with_value(&1u32)) .only(), ); run_test(span, || { @@ -133,7 +132,7 @@ fn parameters_with_fields() { #[test] fn empty_field() { - let span = span::expect().with_field(expect("foo").with_value(&"bar").only()); + let span = expect::span().with_field(expect::field("foo").with_value(&"bar").only()); run_test(span, || { fn_empty_field(); }); @@ -141,7 +140,7 @@ fn empty_field() { #[test] fn string_field() { - let span = span::expect().with_field(expect("s").with_value(&"hello world").only()); + let span = expect::span().with_field(expect::field("s").with_value(&"hello world").only()); run_test(span, || { fn_string(String::from("hello world")); }); @@ -150,8 +149,8 @@ fn string_field() { fn run_test T, T>(span: NewSpan, fun: F) { let (subscriber, handle) = subscriber::mock() .new_span(span) - .enter(span::expect()) - .exit(span::expect()) + .enter(expect::span()) + .exit(expect::span()) .only() .run_with_handle(); diff --git a/tracing-attributes/tests/follows_from.rs b/tracing-attributes/tests/follows_from.rs index 4295442865..6b5526b82e 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::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 cause_a = expect::span().named("cause_a"); + let cause_b = expect::span().named("cause_b"); + let cause_c = expect::span().named("cause_c"); + let consequence = expect::span().named("with_follows_from_sync"); let (subscriber, handle) = subscriber::mock() .new_span(cause_a.clone()) @@ -44,10 +44,10 @@ fn follows_from_sync_test() { #[test] fn follows_from_async_test() { - 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 cause_a = expect::span().named("cause_a"); + let cause_b = expect::span().named("cause_b"); + let cause_c = expect::span().named("cause_c"); + let consequence = expect::span().named("with_follows_from_async"); let (subscriber, handle) = subscriber::mock() .new_span(cause_a.clone()) @@ -79,8 +79,8 @@ fn follows_from_async_test() { #[test] fn follows_from_current_test() { - let cause = span::expect().named("cause"); - let consequence = span::expect().named("follows_from_current"); + let cause = expect::span().named("cause"); + let consequence = expect::span().named("follows_from_current"); let (subscriber, handle) = subscriber::mock() .new_span(cause.clone()) diff --git a/tracing-attributes/tests/instrument.rs b/tracing-attributes/tests/instrument.rs index 41b853c8e0..f751eebf69 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::expect() + let span = expect::span() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::expect() + let span2 = expect::span() .named("my_other_fn") .at_level(Level::DEBUG) .with_target("my_target"); @@ -53,21 +53,21 @@ fn fields() { #[instrument(target = "my_target", level = "debug")] fn my_fn(arg1: usize, arg2: bool) {} - let span = span::expect() + let span = expect::span() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::expect() + let span2 = expect::span() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("arg1") + expect::field("arg1") .with_value(&2usize) - .and(field::expect("arg2").with_value(&false)) + .and(expect::field("arg2").with_value(&false)) .only(), ), ) @@ -76,9 +76,9 @@ fn fields() { .drop_span(span) .new_span( span2.clone().with_field( - field::expect("arg1") + expect::field("arg1") .with_value(&3usize) - .and(field::expect("arg2").with_value(&true)) + .and(expect::field("arg2").with_value(&true)) .only(), ), ) @@ -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::expect() + let span = expect::span() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::expect() + let span2 = expect::span() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span3 = span::expect() + let span3 = expect::span() .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::expect("arg1").with_value(&2usize).only()), + .with_field(expect::field("arg1").with_value(&2usize).only()), ) .enter(span.clone()) .exit(span.clone()) @@ -132,7 +132,7 @@ fn skip() { .new_span( span2 .clone() - .with_field(field::expect("arg1").with_value(&3usize).only()), + .with_field(expect::field("arg1").with_value(&3usize).only()), ) .enter(span2.clone()) .exit(span2.clone()) @@ -165,14 +165,14 @@ fn generics() { { } - let span = span::expect().named("my_fn"); + let span = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("arg1") + expect::field("arg1") .with_value(&format_args!("Foo")) - .and(field::expect("arg2").with_value(&format_args!("false"))), + .and(expect::field("arg2").with_value(&format_args!("false"))), ), ) .enter(span.clone()) @@ -198,14 +198,14 @@ fn methods() { fn my_fn(&self, arg1: usize) {} } - let span = span::expect().named("my_fn"); + let span = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("self") + expect::field("self") .with_value(&format_args!("Foo")) - .and(field::expect("arg1").with_value(&42usize)), + .and(expect::field("arg1").with_value(&42usize)), ), ) .enter(span.clone()) @@ -229,12 +229,12 @@ fn impl_trait_return_type() { 0..x } - let span = span::expect().named("returns_impl_trait"); + let span = expect::span().named("returns_impl_trait"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::expect("x").with_value(&10usize).only()), + .with_field(expect::field("x").with_value(&10usize).only()), ) .enter(span.clone()) .exit(span.clone()) diff --git a/tracing-attributes/tests/levels.rs b/tracing-attributes/tests/levels.rs index b4bb1bd907..ed80dc16a6 100644 --- a/tracing-attributes/tests/levels.rs +++ b/tracing-attributes/tests/levels.rs @@ -20,21 +20,21 @@ fn named_levels() { #[instrument(level = "eRrOr")] fn error() {} let (subscriber, handle) = subscriber::mock() - .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)) + .new_span(expect::span().named("trace").at_level(Level::TRACE)) + .enter(expect::span().named("trace").at_level(Level::TRACE)) + .exit(expect::span().named("trace").at_level(Level::TRACE)) + .new_span(expect::span().named("debug").at_level(Level::DEBUG)) + .enter(expect::span().named("debug").at_level(Level::DEBUG)) + .exit(expect::span().named("debug").at_level(Level::DEBUG)) + .new_span(expect::span().named("info").at_level(Level::INFO)) + .enter(expect::span().named("info").at_level(Level::INFO)) + .exit(expect::span().named("info").at_level(Level::INFO)) + .new_span(expect::span().named("warn").at_level(Level::WARN)) + .enter(expect::span().named("warn").at_level(Level::WARN)) + .exit(expect::span().named("warn").at_level(Level::WARN)) + .new_span(expect::span().named("error").at_level(Level::ERROR)) + .enter(expect::span().named("error").at_level(Level::ERROR)) + .exit(expect::span().named("error").at_level(Level::ERROR)) .only() .run_with_handle(); @@ -66,21 +66,21 @@ fn numeric_levels() { #[instrument(level = 5)] fn error() {} let (subscriber, handle) = subscriber::mock() - .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)) + .new_span(expect::span().named("trace").at_level(Level::TRACE)) + .enter(expect::span().named("trace").at_level(Level::TRACE)) + .exit(expect::span().named("trace").at_level(Level::TRACE)) + .new_span(expect::span().named("debug").at_level(Level::DEBUG)) + .enter(expect::span().named("debug").at_level(Level::DEBUG)) + .exit(expect::span().named("debug").at_level(Level::DEBUG)) + .new_span(expect::span().named("info").at_level(Level::INFO)) + .enter(expect::span().named("info").at_level(Level::INFO)) + .exit(expect::span().named("info").at_level(Level::INFO)) + .new_span(expect::span().named("warn").at_level(Level::WARN)) + .enter(expect::span().named("warn").at_level(Level::WARN)) + .exit(expect::span().named("warn").at_level(Level::WARN)) + .new_span(expect::span().named("error").at_level(Level::ERROR)) + .enter(expect::span().named("error").at_level(Level::ERROR)) + .exit(expect::span().named("error").at_level(Level::ERROR)) .only() .run_with_handle(); @@ -112,21 +112,21 @@ fn enum_levels() { #[instrument(level = Level::ERROR)] fn error() {} let (subscriber, handle) = subscriber::mock() - .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)) + .new_span(expect::span().named("trace").at_level(Level::TRACE)) + .enter(expect::span().named("trace").at_level(Level::TRACE)) + .exit(expect::span().named("trace").at_level(Level::TRACE)) + .new_span(expect::span().named("debug").at_level(Level::DEBUG)) + .enter(expect::span().named("debug").at_level(Level::DEBUG)) + .exit(expect::span().named("debug").at_level(Level::DEBUG)) + .new_span(expect::span().named("info").at_level(Level::INFO)) + .enter(expect::span().named("info").at_level(Level::INFO)) + .exit(expect::span().named("info").at_level(Level::INFO)) + .new_span(expect::span().named("warn").at_level(Level::WARN)) + .enter(expect::span().named("warn").at_level(Level::WARN)) + .exit(expect::span().named("warn").at_level(Level::WARN)) + .new_span(expect::span().named("error").at_level(Level::ERROR)) + .enter(expect::span().named("error").at_level(Level::ERROR)) + .exit(expect::span().named("error").at_level(Level::ERROR)) .only() .run_with_handle(); diff --git a/tracing-attributes/tests/names.rs b/tracing-attributes/tests/names.rs index 6161c68053..03e3dbfa45 100644 --- a/tracing-attributes/tests/names.rs +++ b/tracing-attributes/tests/names.rs @@ -17,9 +17,9 @@ fn custom_name_no_equals() {} #[test] fn default_name_test() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("default_name")) - .enter(span::expect().named("default_name")) - .exit(span::expect().named("default_name")) + .new_span(expect::span().named("default_name")) + .enter(expect::span().named("default_name")) + .exit(expect::span().named("default_name")) .only() .run_with_handle(); @@ -33,9 +33,9 @@ fn default_name_test() { #[test] fn custom_name_test() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("my_name")) - .enter(span::expect().named("my_name")) - .exit(span::expect().named("my_name")) + .new_span(expect::span().named("my_name")) + .enter(expect::span().named("my_name")) + .exit(expect::span().named("my_name")) .only() .run_with_handle(); @@ -49,9 +49,9 @@ fn custom_name_test() { #[test] fn custom_name_no_equals_test() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("my_other_name")) - .enter(span::expect().named("my_other_name")) - .exit(span::expect().named("my_other_name")) + .new_span(expect::span().named("my_other_name")) + .enter(expect::span().named("my_other_name")) + .exit(expect::span().named("my_other_name")) .only() .run_with_handle(); diff --git a/tracing-attributes/tests/parents.rs b/tracing-attributes/tests/parents.rs index d3069f3063..d4559415d9 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::expect().named("contextual_parent"); - let child = span::expect().named("with_default_parent"); + let contextual_parent = expect::span().named("contextual_parent"); + let child = expect::span().named("with_default_parent"); let (subscriber, handle) = subscriber::mock() .new_span( @@ -60,9 +60,9 @@ fn default_parent_test() { #[test] fn explicit_parent_test() { - 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 contextual_parent = expect::span().named("contextual_parent"); + let explicit_parent = expect::span().named("explicit_parent"); + let child = expect::span().named("with_explicit_parent"); let (subscriber, handle) = subscriber::mock() .new_span( diff --git a/tracing-attributes/tests/ret.rs b/tracing-attributes/tests/ret.rs index 40275df3fd..90bd9e185d 100644 --- a/tracing-attributes/tests/ret.rs +++ b/tracing-attributes/tests/ret.rs @@ -19,13 +19,13 @@ fn ret_with_target() -> i32 { #[test] fn test() { - let span = span::expect().named("ret"); + let span = expect::span().named("ret"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) @@ -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::expect() + let span = expect::span() .named("ret_with_target") .with_target("my_target"); @@ -48,8 +48,8 @@ fn test_custom_target() { .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO) .with_target("my_target"), ) @@ -71,13 +71,13 @@ fn ret_warn() -> i32 { #[test] fn test_warn() { - let span = span::expect().named("ret_warn"); + let span = expect::span().named("ret_warn"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::debug(42))) .at_level(Level::WARN), ) .exit(span.clone()) @@ -98,18 +98,18 @@ fn ret_mut(a: &mut i32) -> i32 { #[test] fn test_mut() { - let span = span::expect().named("ret_mut"); + let span = expect::span().named("ret_mut"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("a").with_value(&tracing::field::display(2))) + expect::event() + .with_fields(expect::field("a").with_value(&tracing::field::display(2))) .at_level(Level::INFO), ) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::debug(2))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::debug(2))) .at_level(Level::INFO), ) .exit(span.clone()) @@ -128,13 +128,13 @@ async fn ret_async() -> i32 { #[test] fn test_async() { - let span = span::expect().named("ret_async"); + let span = expect::span().named("ret_async"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) @@ -155,13 +155,13 @@ fn ret_impl_type() -> impl Copy { #[test] fn test_impl_type() { - let span = span::expect().named("ret_impl_type"); + let span = expect::span().named("ret_impl_type"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) @@ -180,13 +180,13 @@ fn ret_display() -> i32 { #[test] fn test_dbg() { - let span = span::expect().named("ret_display"); + let span = expect::span().named("ret_display"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::display(42))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::display(42))) .at_level(Level::INFO), ) .exit(span.clone()) @@ -205,14 +205,14 @@ fn ret_and_err() -> Result { #[test] fn test_ret_and_err() { - let span = span::expect().named("ret_and_err"); + let span = expect::span().named("ret_and_err"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() + expect::event() .with_fields( - field::expect("error") + expect::field("error") .with_value(&tracing::field::display(u8::try_from(1234).unwrap_err())) .only(), ) @@ -234,14 +234,14 @@ fn ret_and_ok() -> Result { #[test] fn test_ret_and_ok() { - let span = span::expect().named("ret_and_ok"); + let span = expect::span().named("ret_and_ok"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() + expect::event() .with_fields( - field::expect("return") + expect::field("return") .with_value(&tracing::field::debug(u8::try_from(123).unwrap())) .only(), ) @@ -263,13 +263,13 @@ fn ret_warn_info() -> i32 { #[test] fn test_warn_info() { - let span = span::expect().named("ret_warn_info").at_level(Level::WARN); + let span = expect::span().named("ret_warn_info").at_level(Level::WARN); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) @@ -288,13 +288,13 @@ fn ret_dbg_warn() -> i32 { #[test] fn test_dbg_warn() { - let span = span::expect().named("ret_dbg_warn").at_level(Level::INFO); + let span = expect::span().named("ret_dbg_warn").at_level(Level::INFO); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::debug(42))) .at_level(Level::WARN), ) .exit(span.clone()) diff --git a/tracing-attributes/tests/targets.rs b/tracing-attributes/tests/targets.rs index 3a545ebff9..0e70287d3e 100644 --- a/tracing-attributes/tests/targets.rs +++ b/tracing-attributes/tests/targets.rs @@ -24,32 +24,32 @@ mod my_mod { fn default_targets() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect() + expect::span() .named("default_target") .with_target(module_path!()), ) .enter( - span::expect() + expect::span() .named("default_target") .with_target(module_path!()), ) .exit( - span::expect() + expect::span() .named("default_target") .with_target(module_path!()), ) .new_span( - span::expect() + expect::span() .named("default_target") .with_target(my_mod::MODULE_PATH), ) .enter( - span::expect() + expect::span() .named("default_target") .with_target(my_mod::MODULE_PATH), ) .exit( - span::expect() + expect::span() .named("default_target") .with_target(my_mod::MODULE_PATH), ) @@ -68,32 +68,32 @@ fn default_targets() { fn custom_targets() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect() + expect::span() .named("custom_target") .with_target("my_target"), ) .enter( - span::expect() + expect::span() .named("custom_target") .with_target("my_target"), ) .exit( - span::expect() + expect::span() .named("custom_target") .with_target("my_target"), ) .new_span( - span::expect() + expect::span() .named("custom_target") .with_target("my_other_target"), ) .enter( - span::expect() + expect::span() .named("custom_target") .with_target("my_other_target"), ) .exit( - span::expect() + expect::span() .named("custom_target") .with_target("my_other_target"), ) diff --git a/tracing-futures/src/lib.rs b/tracing-futures/src/lib.rs index 2795d87253..c79e748a0d 100644 --- a/tracing-futures/src/lib.rs +++ b/tracing-futures/src/lib.rs @@ -634,13 +634,13 @@ mod tests { #[test] fn future_enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .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")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -655,13 +655,13 @@ mod tests { #[test] fn future_error_ends_span() { let (subscriber, handle) = subscriber::mock() - .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")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -677,17 +677,17 @@ mod tests { #[test] fn stream_enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .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")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .run_with_handle(); with_default(subscriber, || { stream::iter_ok::<_, ()>(&[1, 2, 3]) @@ -702,14 +702,14 @@ mod tests { // #[test] // fn span_follows_future_onto_threadpool() { // let (subscriber, handle) = subscriber::mock() - // .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")) + // .enter(expect::span().named("a")) + // .enter(expect::span().named("b")) + // .exit(expect::span().named("b")) + // .enter(expect::span().named("b")) + // .exit(expect::span().named("b")) + // .drop_span(expect::span().named("b")) + // .exit(expect::span().named("a")) + // .drop_span(expect::span().named("a")) // .only() // .run_with_handle(); // let mut runtime = tokio::runtime::Runtime::new().unwrap(); @@ -740,15 +740,15 @@ mod tests { #[test] fn stream_enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .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")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().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::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")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().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 71f888ce0b..4f29fd73cd 100644 --- a/tracing-futures/tests/std_future.rs +++ b/tracing-futures/tests/std_future.rs @@ -8,13 +8,13 @@ use tracing_mock::*; #[test] fn enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .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")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -27,13 +27,13 @@ fn enter_exit_is_reasonable() { #[test] fn error_ends_span() { let (subscriber, handle) = subscriber::mock() - .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")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -66,16 +66,16 @@ fn span_on_drop() { } let subscriber = subscriber::mock() - .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")) + .enter(expect::span().named("foo")) + .event(expect::event().at_level(Level::INFO)) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) + .enter(expect::span().named("bar")) + .event(expect::event().at_level(Level::INFO)) + .exit(expect::span().named("bar")) + .drop_span(expect::span().named("bar")) .only() .run(); diff --git a/tracing-mock/src/event.rs b/tracing-mock/src/event.rs index cd3bef76a3..0713ec0bae 100644 --- a/tracing-mock/src/event.rs +++ b/tracing-mock/src/event.rs @@ -1,5 +1,5 @@ #![allow(missing_docs)] -use super::{field, metadata::ExpectedMetadata, span, Parent}; +use super::{expect, field, metadata::ExpectedMetadata, span, Parent}; use std::fmt; @@ -9,20 +9,14 @@ use std::fmt; /// `subscriber` module. #[derive(Default, Eq, PartialEq)] pub struct ExpectedEvent { - fields: Option, - parent: Option, - in_spans: Vec, - metadata: ExpectedMetadata, -} - -pub fn expect() -> ExpectedEvent { - ExpectedEvent { - ..Default::default() - } + pub(super) fields: Option, + pub(super) parent: Option, + pub(super) in_spans: Vec, + pub(super) metadata: ExpectedMetadata, } pub fn msg(message: impl fmt::Display) -> ExpectedEvent { - expect().with_fields(field::msg(message)) + expect::event().with_fields(field::msg(message)) } impl ExpectedEvent { diff --git a/tracing-mock/src/expectation.rs b/tracing-mock/src/expect.rs similarity index 51% rename from tracing-mock/src/expectation.rs rename to tracing-mock/src/expect.rs index cd48728ae7..a21f260e8d 100644 --- a/tracing-mock/src/expectation.rs +++ b/tracing-mock/src/expect.rs @@ -1,6 +1,6 @@ use crate::{ event::ExpectedEvent, - field::ExpectedFields, + field::{ExpectedField, ExpectedFields, ExpectedValue}, span::{ExpectedSpan, NewSpan}, }; @@ -19,3 +19,25 @@ pub(crate) enum Expect { NewSpan(NewSpan), Nothing, } + +pub fn event() -> ExpectedEvent { + ExpectedEvent { + ..Default::default() + } +} + +pub fn field(name: K) -> ExpectedField +where + String: From, +{ + ExpectedField { + name: name.into(), + value: ExpectedValue::Any, + } +} + +pub fn span() -> ExpectedSpan { + ExpectedSpan { + ..Default::default() + } +} diff --git a/tracing-mock/src/field.rs b/tracing-mock/src/field.rs index be3f9c47cf..ea5f7a4eb7 100644 --- a/tracing-mock/src/field.rs +++ b/tracing-mock/src/field.rs @@ -15,8 +15,8 @@ pub struct ExpectedFields { #[derive(Debug)] pub struct ExpectedField { - name: String, - value: ExpectedValue, + pub(super) name: String, + pub(super) value: ExpectedValue, } #[derive(Debug)] @@ -55,16 +55,6 @@ impl PartialEq for ExpectedValue { } } -pub fn expect(name: K) -> ExpectedField -where - String: From, -{ - ExpectedField { - name: name.into(), - value: ExpectedValue::Any, - } -} - pub fn msg(message: impl fmt::Display) -> ExpectedField { ExpectedField { name: "message".to_string(), diff --git a/tracing-mock/src/layer.rs b/tracing-mock/src/layer.rs index 85509ab075..c577163dee 100644 --- a/tracing-mock/src/layer.rs +++ b/tracing-mock/src/layer.rs @@ -1,7 +1,7 @@ #![allow(missing_docs, dead_code)] use crate::{ event::ExpectedEvent, - expectation::Expect, + expect::Expect, field::ExpectedFields, span::{ExpectedSpan, NewSpan}, subscriber::MockHandle, diff --git a/tracing-mock/src/lib.rs b/tracing-mock/src/lib.rs index a8ba0865b7..e7a6e8b0e2 100644 --- a/tracing-mock/src/lib.rs +++ b/tracing-mock/src/lib.rs @@ -4,7 +4,7 @@ use std::{ }; pub mod event; -mod expectation; +pub mod expect; pub mod field; mod metadata; pub mod span; diff --git a/tracing-mock/src/span.rs b/tracing-mock/src/span.rs index 35cab3ebb9..9af084fe69 100644 --- a/tracing-mock/src/span.rs +++ b/tracing-mock/src/span.rs @@ -1,5 +1,5 @@ #![allow(missing_docs)] -use super::{field::ExpectedFields, metadata::ExpectedMetadata, Parent}; +use super::{expect, field::ExpectedFields, metadata::ExpectedMetadata, Parent}; use std::fmt; /// A mock span. @@ -18,17 +18,11 @@ pub struct NewSpan { pub(crate) parent: Option, } -pub fn expect() -> ExpectedSpan { - ExpectedSpan { - ..Default::default() - } -} - pub fn named(name: I) -> ExpectedSpan where I: Into, { - expect().named(name) + expect::span().named(name) } impl ExpectedSpan { diff --git a/tracing-mock/src/subscriber.rs b/tracing-mock/src/subscriber.rs index 3049993fe8..f7e2929903 100644 --- a/tracing-mock/src/subscriber.rs +++ b/tracing-mock/src/subscriber.rs @@ -1,7 +1,7 @@ #![allow(missing_docs)] use crate::{ event::ExpectedEvent, - expectation::Expect, + expect::Expect, field::ExpectedFields, span::{ExpectedSpan, NewSpan}, }; 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 478b6e9b20..b6d767739d 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 @@ -1,7 +1,7 @@ #![cfg(feature = "registry")] use tracing::Level; use tracing_mock::{ - event, + expect, layer::{self, MockLayer}, subscriber, }; @@ -107,20 +107,20 @@ fn filter() -> LevelFilter { fn unfiltered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .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)) + .event(expect::event().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle() } fn filtered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().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 2ec008dd68..21dbc1d37c 100644 --- a/tracing-subscriber/tests/env_filter/main.rs +++ b/tracing-subscriber/tests/env_filter/main.rs @@ -3,7 +3,7 @@ mod per_layer; use tracing::{self, subscriber::with_default, Level}; -use tracing_mock::{event, field, layer, span, subscriber}; +use tracing_mock::{expect, layer, span, subscriber}; use tracing_subscriber::{ filter::{EnvFilter, LevelFilter}, prelude::*, @@ -13,9 +13,9 @@ use tracing_subscriber::{ fn level_filter_event() { let filter: EnvFilter = "info".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -38,16 +38,16 @@ fn same_name_spans() { .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .new_span( - span::expect() + expect::span() .named("foo") .at_level(Level::TRACE) - .with_field(field::expect("bar")), + .with_field(expect::field("bar")), ) .new_span( - span::expect() + expect::span() .named("foo") .at_level(Level::TRACE) - .with_field(field::expect("baz")), + .with_field(expect::field("baz")), ) .only() .run_with_handle(); @@ -64,11 +64,11 @@ 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::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")) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG).with_target("stuff")) + .event(expect::event().at_level(Level::WARN).with_target("stuff")) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR).with_target("stuff")) .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -98,7 +98,7 @@ fn level_filter_event_with_target_and_span_global() { let (subscriber, handle) = subscriber::mock() .enter(cool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) @@ -133,11 +133,11 @@ fn not_order_dependent() { let filter: EnvFilter = "stuff=debug,info".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .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")) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG).with_target("stuff")) + .event(expect::event().at_level(Level::WARN).with_target("stuff")) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR).with_target("stuff")) .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -167,8 +167,8 @@ fn add_directive_enables_event() { filter = filter.add_directive("hello=trace".parse().expect("directive should parse")); let (subscriber, finished) = subscriber::mock() - .event(event::expect().at_level(Level::INFO).with_target("hello")) - .event(event::expect().at_level(Level::TRACE).with_target("hello")) + .event(expect::event().at_level(Level::INFO).with_target("hello")) + .event(expect::event().at_level(Level::TRACE).with_target("hello")) .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -187,18 +187,18 @@ fn span_name_filter_is_dynamic() { .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .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")) + .event(expect::event().at_level(Level::INFO)) + .enter(expect::span().named("cool_span")) + .event(expect::event().at_level(Level::DEBUG)) + .enter(expect::span().named("uncool_span")) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::DEBUG)) + .exit(expect::span().named("uncool_span")) + .exit(expect::span().named("cool_span")) + .enter(expect::span().named("uncool_span")) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) + .exit(expect::span().named("uncool_span")) .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -245,9 +245,9 @@ mod per_layer_filter { fn level_filter_event() { let filter: EnvFilter = "info".parse().expect("filter should parse"); let (layer, handle) = layer::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); @@ -271,16 +271,16 @@ mod per_layer_filter { .expect("filter should parse"); let (layer, handle) = layer::mock() .new_span( - span::expect() + expect::span() .named("foo") .at_level(Level::TRACE) - .with_field(field::expect("bar")), + .with_field(expect::field("bar")), ) .new_span( - span::expect() + expect::span() .named("foo") .at_level(Level::TRACE) - .with_field(field::expect("baz")), + .with_field(expect::field("baz")), ) .only() .run_with_handle(); @@ -299,11 +299,11 @@ 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::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")) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG).with_target("stuff")) + .event(expect::event().at_level(Level::WARN).with_target("stuff")) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR).with_target("stuff")) .only() .run_with_handle(); @@ -333,7 +333,7 @@ mod per_layer_filter { let (layer, handle) = layer::mock() .enter(cool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) @@ -366,11 +366,11 @@ mod per_layer_filter { let filter: EnvFilter = "stuff=debug,info".parse().expect("filter should parse"); let (layer, finished) = layer::mock() - .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")) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG).with_target("stuff")) + .event(expect::event().at_level(Level::WARN).with_target("stuff")) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR).with_target("stuff")) .only() .run_with_handle(); @@ -401,8 +401,8 @@ mod per_layer_filter { filter = filter.add_directive("hello=trace".parse().expect("directive should parse")); let (layer, finished) = layer::mock() - .event(event::expect().at_level(Level::INFO).with_target("hello")) - .event(event::expect().at_level(Level::TRACE).with_target("hello")) + .event(expect::event().at_level(Level::INFO).with_target("hello")) + .event(expect::event().at_level(Level::TRACE).with_target("hello")) .only() .run_with_handle(); @@ -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::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) .enter(cool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) .enter(uncool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::WARN) .in_scope(vec![uncool_span.clone()]), ) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![uncool_span.clone()]), ) @@ -446,12 +446,12 @@ mod per_layer_filter { .exit(cool_span) .enter(uncool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::WARN) .in_scope(vec![uncool_span.clone()]), ) .event( - event::expect() + expect::event() .at_level(Level::ERROR) .in_scope(vec![uncool_span.clone()]), ) @@ -497,7 +497,7 @@ mod per_layer_filter { let (layer, handle) = layer::named("layer1") .enter(span.clone()) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![span.clone()]), ) @@ -513,7 +513,7 @@ mod per_layer_filter { let (layer, handle) = layer::named("layer2") .enter(span.clone()) .event( - event::expect() + expect::event() .at_level(Level::INFO) .in_scope(vec![span.clone()]), ) diff --git a/tracing-subscriber/tests/env_filter/per_layer.rs b/tracing-subscriber/tests/env_filter/per_layer.rs index 587d34fb77..229b9ff776 100644 --- a/tracing-subscriber/tests/env_filter/per_layer.rs +++ b/tracing-subscriber/tests/env_filter/per_layer.rs @@ -2,15 +2,15 @@ //! `Layer` filter). #![cfg(feature = "registry")] use super::*; -use tracing_mock::{event, field, layer, span}; +use tracing_mock::{layer, span}; #[test] fn level_filter_event() { let filter: EnvFilter = "info".parse().expect("filter should parse"); let (layer, handle) = layer::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); @@ -34,16 +34,16 @@ fn same_name_spans() { .expect("filter should parse"); let (layer, handle) = layer::mock() .new_span( - span::expect() + expect::span() .named("foo") .at_level(Level::TRACE) - .with_field(field::expect("bar")), + .with_field(expect::field("bar")), ) .new_span( - span::expect() + expect::span() .named("foo") .at_level(Level::TRACE) - .with_field(field::expect("baz")), + .with_field(expect::field("baz")), ) .only() .run_with_handle(); @@ -62,11 +62,11 @@ 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::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")) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG).with_target("stuff")) + .event(expect::event().at_level(Level::WARN).with_target("stuff")) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR).with_target("stuff")) .only() .run_with_handle(); @@ -96,7 +96,7 @@ fn level_filter_event_with_target_and_span() { let (layer, handle) = layer::mock() .enter(cool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) @@ -129,11 +129,11 @@ fn not_order_dependent() { let filter: EnvFilter = "stuff=debug,info".parse().expect("filter should parse"); let (layer, finished) = layer::mock() - .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")) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG).with_target("stuff")) + .event(expect::event().at_level(Level::WARN).with_target("stuff")) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR).with_target("stuff")) .only() .run_with_handle(); @@ -164,8 +164,8 @@ fn add_directive_enables_event() { filter = filter.add_directive("hello=trace".parse().expect("directive should parse")); let (layer, finished) = layer::mock() - .event(event::expect().at_level(Level::INFO).with_target("hello")) - .event(event::expect().at_level(Level::TRACE).with_target("hello")) + .event(expect::event().at_level(Level::INFO).with_target("hello")) + .event(expect::event().at_level(Level::TRACE).with_target("hello")) .only() .run_with_handle(); @@ -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::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) .enter(cool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) .enter(uncool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::WARN) .in_scope(vec![uncool_span.clone()]), ) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![uncool_span.clone()]), ) @@ -209,12 +209,12 @@ fn span_name_filter_is_dynamic() { .exit(cool_span) .enter(uncool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::WARN) .in_scope(vec![uncool_span.clone()]), ) .event( - event::expect() + expect::event() .at_level(Level::ERROR) .in_scope(vec![uncool_span.clone()]), ) @@ -260,7 +260,7 @@ fn multiple_dynamic_filters() { let (layer, handle) = layer::named("layer1") .enter(span.clone()) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![span.clone()]), ) @@ -276,7 +276,7 @@ fn multiple_dynamic_filters() { let (layer, handle) = layer::named("layer2") .enter(span.clone()) .event( - event::expect() + expect::event() .at_level(Level::INFO) .in_scope(vec![span.clone()]), ) diff --git a/tracing-subscriber/tests/field_filter.rs b/tracing-subscriber/tests/field_filter.rs index 5d41ec028b..b14aebc421 100644 --- a/tracing-subscriber/tests/field_filter.rs +++ b/tracing-subscriber/tests/field_filter.rs @@ -10,14 +10,14 @@ fn field_filter_events() { let filter: EnvFilter = "[{thing}]=debug".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .event( - event::expect() + expect::event() .at_level(Level::INFO) - .with_fields(field::expect("thing")), + .with_fields(expect::field("thing")), ) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) - .with_fields(field::expect("thing")), + .with_fields(expect::field("thing")), ) .only() .run_with_handle(); @@ -41,22 +41,22 @@ fn field_filter_spans() { .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .enter(span::expect().named("span1")) + .enter(expect::span().named("span1")) .event( - event::expect() + expect::event() .at_level(Level::INFO) - .with_fields(field::expect("something")), + .with_fields(expect::field("something")), ) - .exit(span::expect().named("span1")) - .enter(span::expect().named("span2")) - .exit(span::expect().named("span2")) - .enter(span::expect().named("span3")) + .exit(expect::span().named("span1")) + .enter(expect::span().named("span2")) + .exit(expect::span().named("span2")) + .enter(expect::span().named("span3")) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) - .with_fields(field::expect("something")), + .with_fields(expect::field("something")), ) - .exit(span::expect().named("span3")) + .exit(expect::span().named("span3")) .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -84,15 +84,15 @@ fn record_after_created() { .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .enter(span::expect().named("span")) - .exit(span::expect().named("span")) + .enter(expect::span().named("span")) + .exit(expect::span().named("span")) .record( - span::expect().named("span"), - field::expect("enabled").with_value(&true), + expect::span().named("span"), + expect::field("enabled").with_value(&true), ) - .enter(span::expect().named("span")) - .event(event::expect().at_level(Level::DEBUG)) - .exit(span::expect().named("span")) + .enter(expect::span().named("span")) + .event(expect::event().at_level(Level::DEBUG)) + .exit(expect::span().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 9810684e56..9cda4340e4 100644 --- a/tracing-subscriber/tests/filter_log.rs +++ b/tracing-subscriber/tests/filter_log.rs @@ -36,9 +36,9 @@ fn log_is_enabled() { .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); diff --git a/tracing-subscriber/tests/hinted_layer_filters_dont_break_other_layers.rs b/tracing-subscriber/tests/hinted_layer_filters_dont_break_other_layers.rs index bbb68bd87a..a3ad351580 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,7 +1,7 @@ #![cfg(feature = "registry")] use tracing::{Level, Metadata, Subscriber}; use tracing_mock::{ - event, layer, + expect, layer, layer::MockLayer, subscriber::{self}, }; @@ -115,20 +115,20 @@ fn filter() -> DynFilterFn { fn unfiltered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .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)) + .event(expect::event().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle() } fn filtered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().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 c5f86c3cc9..867fdd0717 100644 --- a/tracing-subscriber/tests/layer_filter_interests_are_cached.rs +++ b/tracing-subscriber/tests/layer_filter_interests_are_cached.rs @@ -4,7 +4,7 @@ use std::{ sync::{Arc, Mutex}, }; use tracing::{Level, Subscriber}; -use tracing_mock::{event, layer}; +use tracing_mock::{expect, layer}; use tracing_subscriber::{filter, prelude::*}; #[test] @@ -21,8 +21,8 @@ fn layer_filter_interests_are_cached() { }); let (expect, handle) = layer::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); diff --git a/tracing-subscriber/tests/layer_filters/filter_scopes.rs b/tracing-subscriber/tests/layer_filters/filter_scopes.rs index b3957e9a30..02d000748f 100644 --- a/tracing-subscriber/tests/layer_filters/filter_scopes.rs +++ b/tracing-subscriber/tests/layer_filters/filter_scopes.rs @@ -1,48 +1,48 @@ use super::*; -use tracing_mock::layer::MockLayer; +use tracing_mock::{event, expect, layer::MockLayer}; #[test] fn filters_span_scopes() { let (debug_layer, debug_handle) = layer::named("debug") - .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)) + .enter(expect::span().at_level(Level::DEBUG)) + .enter(expect::span().at_level(Level::INFO)) + .enter(expect::span().at_level(Level::WARN)) + .enter(expect::span().at_level(Level::ERROR)) .event(event::msg("hello world").in_scope(vec![ - span::expect().at_level(Level::ERROR), - span::expect().at_level(Level::WARN), - span::expect().at_level(Level::INFO), - span::expect().at_level(Level::DEBUG), + expect::span().at_level(Level::ERROR), + expect::span().at_level(Level::WARN), + expect::span().at_level(Level::INFO), + expect::span().at_level(Level::DEBUG), ])) - .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)) + .exit(expect::span().at_level(Level::ERROR)) + .exit(expect::span().at_level(Level::WARN)) + .exit(expect::span().at_level(Level::INFO)) + .exit(expect::span().at_level(Level::DEBUG)) .only() .run_with_handle(); let (info_layer, info_handle) = layer::named("info") - .enter(span::expect().at_level(Level::INFO)) - .enter(span::expect().at_level(Level::WARN)) - .enter(span::expect().at_level(Level::ERROR)) + .enter(expect::span().at_level(Level::INFO)) + .enter(expect::span().at_level(Level::WARN)) + .enter(expect::span().at_level(Level::ERROR)) .event(event::msg("hello world").in_scope(vec![ - span::expect().at_level(Level::ERROR), - span::expect().at_level(Level::WARN), - span::expect().at_level(Level::INFO), + expect::span().at_level(Level::ERROR), + expect::span().at_level(Level::WARN), + expect::span().at_level(Level::INFO), ])) - .exit(span::expect().at_level(Level::ERROR)) - .exit(span::expect().at_level(Level::WARN)) - .exit(span::expect().at_level(Level::INFO)) + .exit(expect::span().at_level(Level::ERROR)) + .exit(expect::span().at_level(Level::WARN)) + .exit(expect::span().at_level(Level::INFO)) .only() .run_with_handle(); let (warn_layer, warn_handle) = layer::named("warn") - .enter(span::expect().at_level(Level::WARN)) - .enter(span::expect().at_level(Level::ERROR)) + .enter(expect::span().at_level(Level::WARN)) + .enter(expect::span().at_level(Level::ERROR)) .event(event::msg("hello world").in_scope(vec![ - span::expect().at_level(Level::ERROR), - span::expect().at_level(Level::WARN), + expect::span().at_level(Level::ERROR), + expect::span().at_level(Level::WARN), ])) - .exit(span::expect().at_level(Level::ERROR)) - .exit(span::expect().at_level(Level::WARN)) + .exit(expect::span().at_level(Level::ERROR)) + .exit(expect::span().at_level(Level::WARN)) .only() .run_with_handle(); @@ -70,22 +70,22 @@ 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::expect().with_target(target)) - .enter(span::expect().with_target(target)) + .enter(expect::span().with_target(target)) + .enter(expect::span().with_target(target)) .event(event::msg("hello world").in_scope(vec![ - span::expect().with_target(target), - span::expect().with_target(target), + expect::span().with_target(target), + expect::span().with_target(target), ])) .event( event::msg("hello to my target") .in_scope(vec![ - span::expect().with_target(target), - span::expect().with_target(target), + expect::span().with_target(target), + expect::span().with_target(target), ]) .with_target(target), ) - .exit(span::expect().with_target(target)) - .exit(span::expect().with_target(target)) + .exit(expect::span().with_target(target)) + .exit(expect::span().with_target(target)) .only() .run_with_handle() } @@ -93,14 +93,14 @@ fn filters_interleaved_span_scopes() { 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::expect().with_target("b")) - .enter(span::expect().with_target("a")) + .enter(expect::span().with_target("b")) + .enter(expect::span().with_target("a")) .event(event::msg("hello world").in_scope(vec![ - span::expect().with_target("a"), - span::expect().with_target("b"), + expect::span().with_target("a"), + expect::span().with_target("b"), ])) - .exit(span::expect().with_target("a")) - .exit(span::expect().with_target("b")) + .exit(expect::span().with_target("a")) + .exit(expect::span().with_target("b")) .only() .run_with_handle(); diff --git a/tracing-subscriber/tests/layer_filters/main.rs b/tracing-subscriber/tests/layer_filters/main.rs index 5b8812f713..170074e8b3 100644 --- a/tracing-subscriber/tests/layer_filters/main.rs +++ b/tracing-subscriber/tests/layer_filters/main.rs @@ -8,26 +8,26 @@ mod trees; mod vec; use tracing::{level_filters::LevelFilter, Level}; -use tracing_mock::{event, layer, span, subscriber}; +use tracing_mock::{event, expect, layer, subscriber}; use tracing_subscriber::{filter, prelude::*, Layer}; #[test] fn basic_subscriber_filters() { let (trace_layer, trace_handle) = layer::named("trace") - .event(event::expect().at_level(Level::TRACE)) - .event(event::expect().at_level(Level::DEBUG)) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); let (debug_layer, debug_handle) = layer::named("debug") - .event(event::expect().at_level(Level::DEBUG)) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); let (info_layer, info_handle) = layer::named("info") - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); @@ -49,20 +49,20 @@ fn basic_subscriber_filters() { #[test] fn basic_subscriber_filters_spans() { let (trace_layer, trace_handle) = layer::named("trace") - .new_span(span::expect().at_level(Level::TRACE)) - .new_span(span::expect().at_level(Level::DEBUG)) - .new_span(span::expect().at_level(Level::INFO)) + .new_span(expect::span().at_level(Level::TRACE)) + .new_span(expect::span().at_level(Level::DEBUG)) + .new_span(expect::span().at_level(Level::INFO)) .only() .run_with_handle(); let (debug_layer, debug_handle) = layer::named("debug") - .new_span(span::expect().at_level(Level::DEBUG)) - .new_span(span::expect().at_level(Level::INFO)) + .new_span(expect::span().at_level(Level::DEBUG)) + .new_span(expect::span().at_level(Level::INFO)) .only() .run_with_handle(); let (info_layer, info_handle) = layer::named("info") - .new_span(span::expect().at_level(Level::INFO)) + .new_span(expect::span().at_level(Level::INFO)) .only() .run_with_handle(); @@ -84,9 +84,9 @@ fn basic_subscriber_filters_spans() { #[test] fn global_filters_subscribers_still_work() { let (expect, handle) = layer::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); @@ -107,8 +107,8 @@ fn global_filters_subscribers_still_work() { #[test] fn global_filter_interests_are_cached() { let (expect, handle) = layer::mock() - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); @@ -135,9 +135,9 @@ fn global_filter_interests_are_cached() { #[test] fn global_filters_affect_subscriber_filters() { let (expect, handle) = layer::named("debug") - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); diff --git a/tracing-subscriber/tests/layer_filters/per_event.rs b/tracing-subscriber/tests/layer_filters/per_event.rs index 9eb9855426..897c9f2df5 100644 --- a/tracing-subscriber/tests/layer_filters/per_event.rs +++ b/tracing-subscriber/tests/layer_filters/per_event.rs @@ -1,5 +1,5 @@ use tracing::Level; -use tracing_mock::{event, layer}; +use tracing_mock::{expect, layer}; use tracing_subscriber::{field::Visit, layer::Filter, prelude::*}; struct FilterEvent; @@ -42,8 +42,8 @@ impl Filter for FilterEvent { #[test] fn per_layer_event_field_filtering() { let (expect, handle) = layer::mock() - .event(event::expect().at_level(Level::TRACE)) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); diff --git a/tracing-subscriber/tests/layer_filters/targets.rs b/tracing-subscriber/tests/layer_filters/targets.rs index 56f6448822..19bcff1489 100644 --- a/tracing-subscriber/tests/layer_filters/targets.rs +++ b/tracing-subscriber/tests/layer_filters/targets.rs @@ -1,4 +1,5 @@ use super::*; +use tracing_mock::event; use tracing_subscriber::{ filter::{filter_fn, Targets}, prelude::*, diff --git a/tracing-subscriber/tests/layer_filters/trees.rs b/tracing-subscriber/tests/layer_filters/trees.rs index 1418fc40fa..a0dbbbe907 100644 --- a/tracing-subscriber/tests/layer_filters/trees.rs +++ b/tracing-subscriber/tests/layer_filters/trees.rs @@ -1,11 +1,11 @@ use super::*; -use tracing_mock::layer::MockLayer; +use tracing_mock::{event, expect, layer::MockLayer}; #[test] fn basic_trees() { let (with_target, with_target_handle) = layer::named("info_with_target") .event( - event::expect() + expect::event() .at_level(Level::INFO) .with_target("my_target"), ) @@ -14,12 +14,12 @@ fn basic_trees() { let (info, info_handle) = layer::named("info") .event( - event::expect() + expect::event() .at_level(Level::INFO) .with_target(module_path!()), ) .event( - event::expect() + expect::event() .at_level(Level::INFO) .with_target("my_target"), ) @@ -28,18 +28,18 @@ fn basic_trees() { let (all, all_handle) = layer::named("all") .event( - event::expect() + expect::event() .at_level(Level::INFO) .with_target(module_path!()), ) - .event(event::expect().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::TRACE)) .event( - event::expect() + expect::event() .at_level(Level::INFO) .with_target("my_target"), ) .event( - event::expect() + expect::event() .at_level(Level::TRACE) .with_target("my_target"), ) @@ -69,11 +69,11 @@ fn basic_trees() { fn filter_span_scopes() { fn target_layer(target: &'static str) -> (MockLayer, subscriber::MockHandle) { layer::named(format!("target_{}", target)) - .enter(span::expect().with_target(target).at_level(Level::INFO)) + .enter(expect::span().with_target(target).at_level(Level::INFO)) .event(event::msg("hello world").in_scope(vec![ - span::expect().with_target(target).at_level(Level::INFO), + expect::span().with_target(target).at_level(Level::INFO), ])) - .exit(span::expect().with_target(target).at_level(Level::INFO)) + .exit(expect::span().with_target(target).at_level(Level::INFO)) .only() .run_with_handle() } @@ -81,28 +81,28 @@ fn filter_span_scopes() { 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::expect().with_target("b").at_level(Level::INFO)) - .enter(span::expect().with_target("a").at_level(Level::INFO)) + .enter(expect::span().with_target("b").at_level(Level::INFO)) + .enter(expect::span().with_target("a").at_level(Level::INFO)) .event(event::msg("hello world").in_scope(vec![ - span::expect().with_target("a").at_level(Level::INFO), - span::expect().with_target("b").at_level(Level::INFO), + expect::span().with_target("a").at_level(Level::INFO), + expect::span().with_target("b").at_level(Level::INFO), ])) - .exit(span::expect().with_target("a").at_level(Level::INFO)) - .exit(span::expect().with_target("b").at_level(Level::INFO)) + .exit(expect::span().with_target("a").at_level(Level::INFO)) + .exit(expect::span().with_target("b").at_level(Level::INFO)) .only() .run_with_handle(); let full_scope = vec![ - 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), + expect::span().with_target("b").at_level(Level::TRACE), + expect::span().with_target("a").at_level(Level::INFO), + expect::span().with_target("b").at_level(Level::INFO), + expect::span().with_target("a").at_level(Level::TRACE), ]; let (all_layer, all_handle) = layer::named("all") - .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)) + .enter(expect::span().with_target("a").at_level(Level::TRACE)) + .enter(expect::span().with_target("b").at_level(Level::INFO)) + .enter(expect::span().with_target("a").at_level(Level::INFO)) + .enter(expect::span().with_target("b").at_level(Level::TRACE)) .event(event::msg("hello world").in_scope(full_scope.clone())) .event( event::msg("hello to my target") @@ -114,10 +114,10 @@ fn filter_span_scopes() { .with_target("b") .in_scope(full_scope), ) - .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)) + .exit(expect::span().with_target("b").at_level(Level::TRACE)) + .exit(expect::span().with_target("a").at_level(Level::INFO)) + .exit(expect::span().with_target("b").at_level(Level::INFO)) + .exit(expect::span().with_target("a").at_level(Level::TRACE)) .only() .run_with_handle(); diff --git a/tracing-subscriber/tests/layer_filters/vec.rs b/tracing-subscriber/tests/layer_filters/vec.rs index 884ec60a95..3555e19545 100644 --- a/tracing-subscriber/tests/layer_filters/vec.rs +++ b/tracing-subscriber/tests/layer_filters/vec.rs @@ -1,26 +1,26 @@ use super::*; use tracing::Subscriber; -use tracing_mock::layer::MockLayer; +use tracing_mock::{expect, layer::MockLayer}; #[test] fn with_filters_unboxed() { let (trace_layer, trace_handle) = layer::named("trace") - .event(event::expect().at_level(Level::TRACE)) - .event(event::expect().at_level(Level::DEBUG)) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().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::expect().at_level(Level::DEBUG)) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().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::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); let info_layer = info_layer.with_filter(LevelFilter::INFO); @@ -41,22 +41,22 @@ fn with_filters_unboxed() { #[test] fn with_filters_boxed() { let (unfiltered_layer, unfiltered_handle) = layer::named("unfiltered") - .event(event::expect().at_level(Level::TRACE)) - .event(event::expect().at_level(Level::DEBUG)) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); let unfiltered_layer = unfiltered_layer.boxed(); let (debug_layer, debug_handle) = layer::named("debug") - .event(event::expect().at_level(Level::DEBUG)) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().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::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); let target_layer = target_layer diff --git a/tracing-subscriber/tests/multiple_layer_filter_interests_cached.rs b/tracing-subscriber/tests/multiple_layer_filter_interests_cached.rs index 6f9ee0c310..553c5371a2 100644 --- a/tracing-subscriber/tests/multiple_layer_filter_interests_cached.rs +++ b/tracing-subscriber/tests/multiple_layer_filter_interests_cached.rs @@ -4,7 +4,7 @@ use std::{ sync::{Arc, Mutex}, }; use tracing::{Level, Subscriber}; -use tracing_mock::{event, layer}; +use tracing_mock::{expect, layer}; use tracing_subscriber::{filter, prelude::*}; #[test] @@ -23,12 +23,12 @@ fn multiple_layer_filter_interests_are_cached() { let seen_info = seen_info2; let (info_layer, info_handle) = layer::named("info") - .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)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); let info_layer = info_layer.with_filter(filter); @@ -47,10 +47,10 @@ fn multiple_layer_filter_interests_are_cached() { let seen_warn = seen_warn2; let (warn_layer, warn_handle) = layer::named("warn") - .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)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().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 839d82e61b..ac0b908d28 100644 --- a/tracing-subscriber/tests/same_len_filters.rs +++ b/tracing-subscriber/tests/same_len_filters.rs @@ -10,8 +10,8 @@ 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::expect().at_level(Level::TRACE)) - .event(event::expect().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::TRACE)) .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -31,14 +31,14 @@ fn same_num_fields_event() { .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .event( - event::expect() + expect::event() .at_level(Level::TRACE) - .with_fields(field::expect("foo")), + .with_fields(expect::field("foo")), ) .event( - event::expect() + expect::event() .at_level(Level::TRACE) - .with_fields(field::expect("bar")), + .with_fields(expect::field("bar")), ) .only() .run_with_handle(); @@ -58,16 +58,16 @@ fn same_num_fields_and_name_len() { .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .new_span( - span::expect() + expect::span() .named("foo") .at_level(Level::TRACE) - .with_field(field::expect("bar")), + .with_field(expect::field("bar")), ) .new_span( - span::expect() + expect::span() .named("baz") .at_level(Level::TRACE) - .with_field(field::expect("boz")), + .with_field(expect::field("boz")), ) .only() .run_with_handle(); 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 9078b66b35..a0f3b51423 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 @@ -1,7 +1,7 @@ #![cfg(feature = "registry")] use tracing::Level; use tracing_mock::{ - event, + expect, layer::{self, MockLayer}, subscriber, }; @@ -107,20 +107,20 @@ fn filter() -> DynFilterFn { fn unfiltered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .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)) + .event(expect::event().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle() } fn filtered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle() } diff --git a/tracing-subscriber/tests/utils.rs b/tracing-subscriber/tests/utils.rs index 6cf96b066e..9a8eb30ace 100644 --- a/tracing-subscriber/tests/utils.rs +++ b/tracing-subscriber/tests/utils.rs @@ -7,7 +7,7 @@ use tracing_subscriber::prelude::*; fn init_ext_works() { let (subscriber, finished) = subscriber::mock() .event( - event::expect() + expect::event() .at_level(tracing::Level::INFO) .with_target("init_works"), ) diff --git a/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs b/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs index 9a9f117cdd..8e1ecabce1 100644 --- a/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs +++ b/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs @@ -23,22 +23,22 @@ fn vec_subscriber_filter_interests_are_cached() { // This layer will return Interest::always for INFO and lower. let (info_layer, info_handle) = layer::named("info") - .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)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().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::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)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); let (warn_layer, seen_warn) = mk_filtered(Level::WARN, warn_layer); diff --git a/tracing/tests/event.rs b/tracing/tests/event.rs index 6e943c60db..5a0dc9ce4a 100644 --- a/tracing/tests/event.rs +++ b/tracing/tests/event.rs @@ -22,11 +22,11 @@ macro_rules! event_without_message { fn $name() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("answer") + expect::event().with_fields( + expect::field("answer") .with_value(&42) .and( - field::expect("to_question") + expect::field("to_question") .with_value(&"life, the universe, and everything"), ) .only(), @@ -58,7 +58,7 @@ event_without_message! {nonzeroi32_event_without_message: std::num::NonZeroI32:: fn event_with_message() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields(field::expect("message").with_value( + expect::event().with_fields(expect::field("message").with_value( &tracing::field::debug(format_args!( "hello from my tracing::event! yak shaved = {:?}", true @@ -80,11 +80,11 @@ fn event_with_message() { fn message_without_delims() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("answer") + expect::event().with_fields( + expect::field("answer") .with_value(&42) .and( - field::expect("question").with_value(&"life, the universe, and everything"), + expect::field("question").with_value(&"life, the universe, and everything"), ) .and(field::msg(format_args!( "hello from my event! tricky? {:?}!", @@ -109,11 +109,11 @@ fn message_without_delims() { fn string_message_without_delims() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("answer") + expect::event().with_fields( + expect::field("answer") .with_value(&42) .and( - field::expect("question").with_value(&"life, the universe, and everything"), + expect::field("question").with_value(&"life, the universe, and everything"), ) .and(field::msg(format_args!("hello from my event"))) .only(), @@ -135,17 +135,17 @@ fn string_message_without_delims() { fn one_with_everything() { let (subscriber, handle) = subscriber::mock() .event( - event::expect() + expect::event() .with_fields( - field::expect("message") + expect::field("message") .with_value(&tracing::field::debug(format_args!( "{:#x} make me one with{what:.>20}", 4_277_009_102u64, what = "everything" ))) - .and(field::expect("foo").with_value(&666)) - .and(field::expect("bar").with_value(&false)) - .and(field::expect("like_a_butterfly").with_value(&42.0)) + .and(expect::field("foo").with_value(&666)) + .and(expect::field("bar").with_value(&false)) + .and(expect::field("like_a_butterfly").with_value(&42.0)) .only(), ) .at_level(Level::ERROR) @@ -171,8 +171,8 @@ fn one_with_everything() { fn moved_field() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("foo") + expect::event().with_fields( + expect::field("foo") .with_value(&display("hello from my event")) .only(), ), @@ -192,10 +192,10 @@ fn moved_field() { fn dotted_field_name() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("foo.bar") + expect::event().with_fields( + expect::field("foo.bar") .with_value(&true) - .and(field::expect("foo.baz").with_value(&false)) + .and(expect::field("foo.baz").with_value(&false)) .only(), ), ) @@ -213,8 +213,8 @@ fn dotted_field_name() { fn borrowed_field() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("foo") + expect::event().with_fields( + expect::field("foo") .with_value(&display("hello from my event")) .only(), ), @@ -250,14 +250,14 @@ fn move_field_out_of_struct() { }; let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("x") + expect::event().with_fields( + expect::field("x") .with_value(&debug(3.234)) - .and(field::expect("y").with_value(&debug(-1.223))) + .and(expect::field("y").with_value(&debug(-1.223))) .only(), ), ) - .event(event::expect().with_fields(field::expect("position").with_value(&debug(&pos)))) + .event(expect::event().with_fields(expect::field("position").with_value(&debug(&pos)))) .only() .run_with_handle(); @@ -277,8 +277,8 @@ fn move_field_out_of_struct() { fn display_shorthand() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("my_field") + expect::event().with_fields( + expect::field("my_field") .with_value(&display("hello world")) .only(), ), @@ -297,8 +297,8 @@ fn display_shorthand() { fn debug_shorthand() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("my_field") + expect::event().with_fields( + expect::field("my_field") .with_value(&debug("hello world")) .only(), ), @@ -317,10 +317,10 @@ fn debug_shorthand() { fn both_shorthands() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("display_field") + expect::event().with_fields( + expect::field("display_field") .with_value(&display("hello world")) - .and(field::expect("debug_field").with_value(&debug("hello world"))) + .and(expect::field("debug_field").with_value(&debug("hello world"))) .only(), ), ) @@ -337,8 +337,8 @@ fn both_shorthands() { #[test] fn explicit_child() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo")) - .event(event::expect().with_explicit_parent(Some("foo"))) + .new_span(expect::span().named("foo")) + .event(expect::event().with_explicit_parent(Some("foo"))) .only() .run_with_handle(); @@ -354,12 +354,12 @@ fn explicit_child() { #[test] fn explicit_child_at_levels() { let (subscriber, handle) = subscriber::mock() - .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"))) + .new_span(expect::span().named("foo")) + .event(expect::event().with_explicit_parent(Some("foo"))) + .event(expect::event().with_explicit_parent(Some("foo"))) + .event(expect::event().with_explicit_parent(Some("foo"))) + .event(expect::event().with_explicit_parent(Some("foo"))) + .event(expect::event().with_explicit_parent(Some("foo"))) .only() .run_with_handle(); @@ -380,11 +380,11 @@ fn explicit_child_at_levels() { fn option_values() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("some_str") + expect::event().with_fields( + expect::field("some_str") .with_value(&"yes") - .and(field::expect("some_bool").with_value(&true)) - .and(field::expect("some_u64").with_value(&42_u64)) + .and(expect::field("some_bool").with_value(&true)) + .and(expect::field("some_u64").with_value(&42_u64)) .only(), ), ) @@ -416,11 +416,11 @@ fn option_values() { fn option_ref_values() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("some_str") + expect::event().with_fields( + expect::field("some_str") .with_value(&"yes") - .and(field::expect("some_bool").with_value(&true)) - .and(field::expect("some_u64").with_value(&42_u64)) + .and(expect::field("some_bool").with_value(&true)) + .and(expect::field("some_u64").with_value(&42_u64)) .only(), ), ) @@ -452,11 +452,11 @@ fn option_ref_values() { fn option_ref_mut_values() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("some_str") + expect::event().with_fields( + expect::field("some_str") .with_value(&"yes") - .and(field::expect("some_bool").with_value(&true)) - .and(field::expect("some_u64").with_value(&42_u64)) + .and(expect::field("some_bool").with_value(&true)) + .and(expect::field("some_u64").with_value(&42_u64)) .only(), ), ) @@ -487,10 +487,10 @@ fn option_ref_mut_values() { #[test] fn string_field() { let (subscriber, handle) = subscriber::mock() - .event(event::expect().with_fields(field::expect("my_string").with_value(&"hello").only())) + .event(expect::event().with_fields(expect::field("my_string").with_value(&"hello").only())) .event( - event::expect().with_fields( - field::expect("my_string") + expect::event().with_fields( + expect::field("my_string") .with_value(&"hello world!") .only(), ), diff --git a/tracing/tests/filters_dont_leak.rs b/tracing/tests/filters_dont_leak.rs index df96a4ac72..c46b91f18f 100644 --- a/tracing/tests/filters_dont_leak.rs +++ b/tracing/tests/filters_dont_leak.rs @@ -20,7 +20,7 @@ fn spans_dont_leak() { do_span(); - let alice = span::expect().named("alice"); + let alice = expect::span().named("alice"); let (subscriber2, handle2) = subscriber::mock() .named("spans/subscriber2") .with_filter(|_| true) @@ -63,7 +63,7 @@ fn events_dont_leak() { let (subscriber2, handle2) = subscriber::mock() .named("events/subscriber2") .with_filter(|_| true) - .event(event::expect()) + .event(expect::event()) .only() .run_with_handle(); diff --git a/tracing/tests/instrument.rs b/tracing/tests/instrument.rs index 07b6bbfa42..5247249946 100644 --- a/tracing/tests/instrument.rs +++ b/tracing/tests/instrument.rs @@ -33,16 +33,16 @@ fn span_on_drop() { } let subscriber = subscriber::mock() - .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")) + .enter(expect::span().named("foo")) + .event(expect::event().at_level(Level::INFO)) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) + .enter(expect::span().named("bar")) + .event(expect::event().at_level(Level::INFO)) + .exit(expect::span().named("bar")) + .drop_span(expect::span().named("bar")) .only() .run(); diff --git a/tracing/tests/max_level_hint.rs b/tracing/tests/max_level_hint.rs index 5c7c476bf3..2e04bc3f1d 100644 --- a/tracing/tests/max_level_hint.rs +++ b/tracing/tests/max_level_hint.rs @@ -20,9 +20,9 @@ fn max_level_hints() { ); true }) - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); diff --git a/tracing/tests/multiple_max_level_hints.rs b/tracing/tests/multiple_max_level_hints.rs index 81cc8052e9..f78fda70fb 100644 --- a/tracing/tests/multiple_max_level_hints.rs +++ b/tracing/tests/multiple_max_level_hints.rs @@ -35,9 +35,9 @@ fn multiple_max_level_hints() { ); level <= &Level::INFO }) - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); let (subscriber2, handle2) = subscriber::mock() @@ -51,10 +51,10 @@ fn multiple_max_level_hints() { ); level <= &Level::DEBUG }) - .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)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); diff --git a/tracing/tests/span.rs b/tracing/tests/span.rs index 40ba193da8..d75f3a89a8 100644 --- a/tracing/tests/span.rs +++ b/tracing/tests/span.rs @@ -67,11 +67,11 @@ 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::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run(); let subscriber2 = subscriber::mock().run(); @@ -94,11 +94,11 @@ 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::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run(); let foo = with_default(subscriber1, || { @@ -122,9 +122,9 @@ 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::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -140,10 +140,10 @@ fn dropping_a_span_calls_drop_span() { #[test] fn span_closes_after_event() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .event(event::expect()) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .event(expect::event()) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -159,13 +159,13 @@ fn span_closes_after_event() { #[test] fn new_span_after_event() { let (subscriber, handle) = subscriber::mock() - .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")) + .enter(expect::span().named("foo")) + .event(expect::event()) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) + .enter(expect::span().named("bar")) + .exit(expect::span().named("bar")) + .drop_span(expect::span().named("bar")) .only() .run_with_handle(); with_default(subscriber, || { @@ -182,10 +182,10 @@ fn new_span_after_event() { #[test] fn event_outside_of_span() { let (subscriber, handle) = subscriber::mock() - .event(event::expect()) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .event(expect::event()) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -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::expect().named("foo")) + .clone_span(expect::span().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::expect().named("foo")) - .drop_span(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .clone_span(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .run_with_handle(); with_default(subscriber, || { let span = tracing::span!(Level::TRACE, "foo"); @@ -233,13 +233,13 @@ 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::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")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .clone_span(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .run_with_handle(); let subscriber2 = subscriber::mock().only().run(); @@ -264,9 +264,9 @@ 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::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -284,10 +284,10 @@ fn span_closes_when_exited() { #[test] fn enter() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .event(event::expect()) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .event(expect::event()) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -303,10 +303,10 @@ fn enter() { #[test] fn entered() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .event(event::expect()) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .event(expect::event()) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -321,10 +321,10 @@ fn entered() { #[test] fn entered_api() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .event(event::expect()) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .event(expect::event()) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -342,15 +342,15 @@ fn entered_api() { fn moved_field() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("foo").with_field( - field::expect("bar") + expect::span().named("foo").with_field( + expect::field("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -371,9 +371,9 @@ fn moved_field() { fn dotted_field_name() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect() + expect::span() .named("foo") - .with_field(field::expect("fields.bar").with_value(&true).only()), + .with_field(expect::field("fields.bar").with_value(&true).only()), ) .only() .run_with_handle(); @@ -389,15 +389,15 @@ fn dotted_field_name() { fn borrowed_field() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("foo").with_field( - field::expect("bar") + expect::span().named("foo").with_field( + expect::field("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); @@ -432,17 +432,17 @@ fn move_field_out_of_struct() { }; let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("foo").with_field( - field::expect("x") + expect::span().named("foo").with_field( + expect::field("x") .with_value(&debug(3.234)) - .and(field::expect("y").with_value(&debug(-1.223))) + .and(expect::field("y").with_value(&debug(-1.223))) .only(), ), ) .new_span( - span::expect() + expect::span() .named("bar") - .with_field(field::expect("position").with_value(&debug(&pos)).only()), + .with_field(expect::field("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::expect().named("foo").with_field( - field::expect("x") + expect::span().named("foo").with_field( + expect::field("x") .with_value(&3.234) - .and(field::expect("y").with_value(&-1.223)) + .and(expect::field("y").with_value(&-1.223)) .only(), ), ) @@ -490,18 +490,18 @@ fn float_values() { fn add_field_after_new_span() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect() + expect::span() .named("foo") - .with_field(field::expect("bar").with_value(&5) - .and(field::expect("baz").with_value).only()), + .with_field(expect::field("bar").with_value(&5) + .and(expect::field("baz").with_value).only()), ) .record( - span::expect().named("foo"), + expect::span().named("foo"), field::expect("baz").with_value(&true).only(), ) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); @@ -518,18 +518,18 @@ fn add_field_after_new_span() { #[test] fn add_fields_only_after_new_span() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo")) + .new_span(expect::span().named("foo")) .record( - span::expect().named("foo"), + expect::span().named("foo"), field::expect("bar").with_value(&5).only(), ) .record( - span::expect().named("foo"), + expect::span().named("foo"), field::expect("baz").with_value(&true).only(), ) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); @@ -549,20 +549,20 @@ fn add_fields_only_after_new_span() { fn record_new_value_for_field() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("foo").with_field( - field::expect("bar") + expect::span().named("foo").with_field( + expect::field("bar") .with_value(&5) - .and(field::expect("baz").with_value(&false)) + .and(expect::field("baz").with_value(&false)) .only(), ), ) .record( - span::expect().named("foo"), - field::expect("baz").with_value(&true).only(), + expect::span().named("foo"), + expect::field("baz").with_value(&true).only(), ) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); @@ -580,24 +580,24 @@ fn record_new_value_for_field() { fn record_new_values_for_fields() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("foo").with_field( - field::expect("bar") + expect::span().named("foo").with_field( + expect::field("bar") .with_value(&4) - .and(field::expect("baz").with_value(&false)) + .and(expect::field("baz").with_value(&false)) .only(), ), ) .record( - span::expect().named("foo"), - field::expect("bar").with_value(&5).only(), + expect::span().named("foo"), + expect::field("bar").with_value(&5).only(), ) .record( - span::expect().named("foo"), - field::expect("baz").with_value(&true).only(), + expect::span().named("foo"), + expect::field("baz").with_value(&true).only(), ) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); @@ -616,7 +616,7 @@ fn record_new_values_for_fields() { fn new_span_with_target_and_log_level() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect() + expect::span() .named("foo") .with_target("app_span") .at_level(Level::DEBUG), @@ -635,7 +635,7 @@ fn new_span_with_target_and_log_level() { #[test] fn explicit_root_span_is_root() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo").with_explicit_parent(None)) + .new_span(expect::span().named("foo").with_explicit_parent(None)) .only() .run_with_handle(); @@ -650,10 +650,10 @@ fn explicit_root_span_is_root() { #[test] fn explicit_root_span_is_root_regardless_of_ctx() { let (subscriber, handle) = subscriber::mock() - .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")) + .new_span(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .new_span(expect::span().named("bar").with_explicit_parent(None)) + .exit(expect::span().named("foo")) .only() .run_with_handle(); @@ -670,9 +670,9 @@ fn explicit_root_span_is_root_regardless_of_ctx() { #[test] fn explicit_child() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo")) + .new_span(expect::span().named("foo")) .new_span( - span::expect() + expect::span() .named("bar") .with_explicit_parent(Some("foo")), ) @@ -691,12 +691,12 @@ fn explicit_child() { #[test] fn explicit_child_at_levels() { let (subscriber, handle) = subscriber::mock() - .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"))) + .new_span(expect::span().named("foo")) + .new_span(expect::span().named("a").with_explicit_parent(Some("foo"))) + .new_span(expect::span().named("b").with_explicit_parent(Some("foo"))) + .new_span(expect::span().named("c").with_explicit_parent(Some("foo"))) + .new_span(expect::span().named("d").with_explicit_parent(Some("foo"))) + .new_span(expect::span().named("e").with_explicit_parent(Some("foo"))) .only() .run_with_handle(); @@ -716,15 +716,15 @@ fn explicit_child_at_levels() { #[test] fn explicit_child_regardless_of_ctx() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo")) - .new_span(span::expect().named("bar")) - .enter(span::expect().named("bar")) + .new_span(expect::span().named("foo")) + .new_span(expect::span().named("bar")) + .enter(expect::span().named("bar")) .new_span( - span::expect() + expect::span() .named("baz") .with_explicit_parent(Some("foo")), ) - .exit(span::expect().named("bar")) + .exit(expect::span().named("bar")) .only() .run_with_handle(); @@ -741,7 +741,7 @@ fn explicit_child_regardless_of_ctx() { #[test] fn contextual_root() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo").with_contextual_parent(None)) + .new_span(expect::span().named("foo").with_contextual_parent(None)) .only() .run_with_handle(); @@ -756,14 +756,14 @@ fn contextual_root() { #[test] fn contextual_child() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo")) - .enter(span::expect().named("foo")) + .new_span(expect::span().named("foo")) + .enter(expect::span().named("foo")) .new_span( - span::expect() + expect::span() .named("bar") .with_contextual_parent(Some("foo")), ) - .exit(span::expect().named("foo")) + .exit(expect::span().named("foo")) .only() .run_with_handle(); @@ -781,8 +781,8 @@ fn contextual_child() { fn display_shorthand() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("my_span").with_field( - field::expect("my_field") + expect::span().named("my_span").with_field( + expect::field("my_field") .with_value(&display("hello world")) .only(), ), @@ -801,8 +801,8 @@ fn display_shorthand() { fn debug_shorthand() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("my_span").with_field( - field::expect("my_field") + expect::span().named("my_span").with_field( + expect::field("my_field") .with_value(&debug("hello world")) .only(), ), @@ -821,10 +821,10 @@ fn debug_shorthand() { fn both_shorthands() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("my_span").with_field( - field::expect("display_field") + expect::span().named("my_span").with_field( + expect::field("display_field") .with_value(&display("hello world")) - .and(field::expect("debug_field").with_value(&debug("hello world"))) + .and(expect::field("debug_field").with_value(&debug("hello world"))) .only(), ), ) diff --git a/tracing/tests/subscriber.rs b/tracing/tests/subscriber.rs index 0357d61ac7..f676efeee8 100644 --- a/tracing/tests/subscriber.rs +++ b/tracing/tests/subscriber.rs @@ -11,8 +11,7 @@ use tracing::{ subscriber::{with_default, Interest, Subscriber}, Event, Level, Metadata, }; - -use tracing_mock::*; +use tracing_mock::{expect, subscriber}; #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] @@ -61,15 +60,15 @@ fn event_macros_dont_infinite_loop() { fn boxed_subscriber() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("foo").with_field( - field::expect("bar") + expect::span().named("foo").with_field( + expect::field("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); let subscriber: Box = Box::new(subscriber); @@ -94,18 +93,18 @@ fn arced_subscriber() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("foo").with_field( - field::expect("bar") + expect::span().named("foo").with_field( + expect::field("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .event( - event::expect() - .with_fields(field::expect("message").with_value(&display("hello from my event"))), + expect::event() + .with_fields(expect::field("message").with_value(&display("hello from my event"))), ) .only() .run_with_handle();