diff --git a/tracing-attributes/tests/async_fn.rs b/tracing-attributes/tests/async_fn.rs index 16cc89b07c..be2f788785 100644 --- a/tracing-attributes/tests/async_fn.rs +++ b/tracing-attributes/tests/async_fn.rs @@ -84,14 +84,14 @@ fn repro_1831_2() -> impl Future> { #[test] fn async_fn_only_enters_for_polls() { let (collector, handle) = collector::mock() - .new_span(span::mock().named("test_async_fn")) - .enter(span::mock().named("test_async_fn")) - .event(event::mock().with_fields(field::mock("awaiting").with_value(&true))) - .exit(span::mock().named("test_async_fn")) - .enter(span::mock().named("test_async_fn")) - .exit(span::mock().named("test_async_fn")) - .drop_span(span::mock().named("test_async_fn")) - .done() + .new_span(span::expect().named("test_async_fn")) + .enter(span::expect().named("test_async_fn")) + .event(event::expect().with_fields(field::expect("awaiting").with_value(&true))) + .exit(span::expect().named("test_async_fn")) + .enter(span::expect().named("test_async_fn")) + .exit(span::expect().named("test_async_fn")) + .drop_span(span::expect().named("test_async_fn")) + .only() .run_with_handle(); with_default(collector, || { block_on_future(async { test_async_fn(2).await }).unwrap(); @@ -111,19 +111,19 @@ fn async_fn_nested() { tracing::trace!(nested = true); } - let span = span::mock().named("test_async_fns_nested"); - let span2 = span::mock().named("test_async_fns_nested_other"); + let span = span::expect().named("test_async_fns_nested"); + let span2 = span::expect().named("test_async_fns_nested_other"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .new_span(span2.clone()) .enter(span2.clone()) - .event(event::mock().with_fields(field::mock("nested").with_value(&true))) + .event(event::expect().with_fields(field::expect("nested").with_value(&true))) .exit(span2.clone()) .drop_span(span2) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -185,29 +185,29 @@ fn async_fn_with_async_trait() { } } - let span = span::mock().named("foo"); - let span2 = span::mock().named("bar"); - let span3 = span::mock().named("baz"); + let span = span::expect().named("foo"); + let span2 = span::expect().named("bar"); + let span3 = span::expect().named("baz"); let (collector, handle) = collector::mock() .new_span( span.clone() - .with_field(field::mock("self")) - .with_field(field::mock("v")), + .with_field(field::expect("self")) + .with_field(field::expect("v")), ) .enter(span.clone()) .new_span(span3.clone()) .enter(span3.clone()) - .event(event::mock().with_fields(field::mock("val").with_value(&2u64))) + .event(event::expect().with_fields(field::expect("val").with_value(&2u64))) .exit(span3.clone()) .drop_span(span3) - .new_span(span2.clone().with_field(field::mock("self"))) + .new_span(span2.clone().with_field(field::expect("self"))) .enter(span2.clone()) - .event(event::mock().with_fields(field::mock("val").with_value(&5u64))) + .event(event::expect().with_fields(field::expect("val").with_value(&5u64))) .exit(span2.clone()) .drop_span(span2) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -243,21 +243,21 @@ fn async_fn_with_async_trait_and_fields_expressions() { async fn call(&mut self, _v: usize) {} } - let span = span::mock().named("call"); + let span = span::expect().named("call"); let (collector, handle) = collector::mock() .new_span( span.clone().with_field( - field::mock("_v") + field::expect("_v") .with_value(&5usize) - .and(field::mock("test").with_value(&tracing::field::debug(10))) - .and(field::mock("val").with_value(&42u64)) - .and(field::mock("val2").with_value(&42u64)), + .and(field::expect("test").with_value(&tracing::field::debug(10))) + .and(field::expect("val").with_value(&42u64)) + .and(field::expect("val2").with_value(&42u64)), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -309,26 +309,26 @@ fn async_fn_with_async_trait_and_fields_expressions_with_generic_parameter() { } //let span = span::mock().named("call"); - let span2 = span::mock().named("call_with_self"); - let span3 = span::mock().named("call_with_mut_self"); - let span4 = span::mock().named("sync_fun"); + let span2 = span::expect().named("call_with_self"); + let span3 = span::expect().named("call_with_mut_self"); + let span4 = span::expect().named("sync_fun"); let (collector, handle) = collector::mock() /*.new_span(span.clone() .with_field( - field::mock("Self").with_value(&"TestImpler"))) + field::expect("Self").with_value(&"TestImpler"))) .enter(span.clone()) .exit(span.clone()) .drop_span(span)*/ .new_span( span2 .clone() - .with_field(field::mock("Self").with_value(&std::any::type_name::())), + .with_field(field::expect("Self").with_value(&std::any::type_name::())), ) .enter(span2.clone()) .new_span( span4 .clone() - .with_field(field::mock("Self").with_value(&std::any::type_name::())), + .with_field(field::expect("Self").with_value(&std::any::type_name::())), ) .enter(span4.clone()) .exit(span4) @@ -337,12 +337,12 @@ fn async_fn_with_async_trait_and_fields_expressions_with_generic_parameter() { .new_span( span3 .clone() - .with_field(field::mock("Self").with_value(&std::any::type_name::())), + .with_field(field::expect("Self").with_value(&std::any::type_name::())), ) .enter(span3.clone()) .exit(span3.clone()) .drop_span(span3) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -377,13 +377,13 @@ fn out_of_scope_fields() { } } - let span = span::mock().named("call"); + let span = span::expect().named("call"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -408,8 +408,8 @@ fn manual_impl_future() { } } - let span = span::mock().named("manual_impl_future"); - let poll_event = || event::mock().with_fields(field::mock("poll").with_value(&true)); + let span = span::expect().named("manual_impl_future"); + let poll_event = || event::expect().with_fields(field::expect("poll").with_value(&true)); let (collector, handle) = collector::mock() // await manual_impl_future @@ -418,7 +418,7 @@ fn manual_impl_future() { .event(poll_event()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -439,8 +439,8 @@ fn manual_box_pin() { }) } - let span = span::mock().named("manual_box_pin"); - let poll_event = || event::mock().with_fields(field::mock("poll").with_value(&true)); + let span = span::expect().named("manual_box_pin"); + let poll_event = || event::expect().with_fields(field::expect("poll").with_value(&true)); let (collector, handle) = collector::mock() // await manual_box_pin @@ -449,7 +449,7 @@ fn manual_box_pin() { .event(poll_event()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { diff --git a/tracing-attributes/tests/destructuring.rs b/tracing-attributes/tests/destructuring.rs index 8064c406cc..19e489c86d 100644 --- a/tracing-attributes/tests/destructuring.rs +++ b/tracing-attributes/tests/destructuring.rs @@ -7,21 +7,21 @@ fn destructure_tuples() { #[instrument] fn my_fn((arg1, arg2): (usize, usize)) {} - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (collector, handle) = collector::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) + .and(field::expect("arg2").with_value(&format_args!("2"))) .only(), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -36,23 +36,23 @@ fn destructure_nested_tuples() { #[instrument] fn my_fn(((arg1, arg2), (arg3, arg4)): ((usize, usize), (usize, usize))) {} - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (collector, handle) = collector::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) - .and(field::mock("arg3").with_value(&format_args!("3"))) - .and(field::mock("arg4").with_value(&format_args!("4"))) + .and(field::expect("arg2").with_value(&format_args!("2"))) + .and(field::expect("arg3").with_value(&format_args!("3"))) + .and(field::expect("arg4").with_value(&format_args!("4"))) .only(), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -67,17 +67,17 @@ fn destructure_refs() { #[instrument] fn my_fn(&arg1: &usize) {} - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (collector, handle) = collector::mock() .new_span( span.clone() - .with_field(field::mock("arg1").with_value(&1usize).only()), + .with_field(field::expect("arg1").with_value(&1usize).only()), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -94,21 +94,21 @@ fn destructure_tuple_structs() { #[instrument] fn my_fn(Foo(arg1, arg2): Foo) {} - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (collector, handle) = collector::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) + .and(field::expect("arg2").with_value(&format_args!("2"))) .only(), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -135,21 +135,21 @@ fn destructure_structs() { let _ = (arg1, arg2); } - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (collector, handle) = collector::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) + .and(field::expect("arg2").with_value(&format_args!("2"))) .only(), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -180,23 +180,23 @@ fn destructure_everything() { let _ = (arg1, arg2, arg3, arg4); } - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (collector, handle) = collector::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) - .and(field::mock("arg3").with_value(&format_args!("3"))) - .and(field::mock("arg4").with_value(&format_args!("4"))) + .and(field::expect("arg2").with_value(&format_args!("2"))) + .and(field::expect("arg3").with_value(&format_args!("3"))) + .and(field::expect("arg4").with_value(&format_args!("4"))) .only(), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { diff --git a/tracing-attributes/tests/err.rs b/tracing-attributes/tests/err.rs index 842a6e0e3a..a045b1af40 100644 --- a/tracing-attributes/tests/err.rs +++ b/tracing-attributes/tests/err.rs @@ -21,14 +21,14 @@ fn err_suspicious_else() -> Result { #[test] fn test() { - let span = span::mock().named("err"); + let span = span::expect().named("err"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR)) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || err().ok()); handle.assert_finished(); @@ -42,14 +42,14 @@ fn err_early_return() -> Result { #[test] fn test_early_return() { - let span = span::mock().named("err_early_return"); + let span = span::expect().named("err_early_return"); let (subscriber, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR)) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || err_early_return().ok()); handle.assert_finished(); @@ -65,21 +65,21 @@ async fn err_async(polls: usize) -> Result { #[test] fn test_async() { - let span = span::mock().named("err_async"); + let span = span::expect().named("err_async"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("awaiting").with_value(&true)) + event::expect() + .with_fields(field::expect("awaiting").with_value(&true)) .at_level(Level::TRACE), ) .exit(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR)) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { block_on_future(async { err_async(2).await }).ok(); @@ -95,14 +95,14 @@ fn err_mut(out: &mut u8) -> Result<(), TryFromIntError> { #[test] fn test_mut() { - let span = span::mock().named("err_mut"); + let span = span::expect().named("err_mut"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR)) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || err_mut(&mut 0).ok()); handle.assert_finished(); @@ -119,21 +119,21 @@ async fn err_mut_async(polls: usize, out: &mut u8) -> Result<(), TryFromIntError #[test] fn test_mut_async() { - let span = span::mock().named("err_mut_async"); + let span = span::expect().named("err_mut_async"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("awaiting").with_value(&true)) + event::expect() + .with_fields(field::expect("awaiting").with_value(&true)) .at_level(Level::TRACE), ) .exit(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR)) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { block_on_future(async { err_mut_async(2, &mut 0).await }).ok(); @@ -150,17 +150,17 @@ fn impl_trait_return_type() { Ok(0..x) } - let span = span::mock().named("returns_impl_trait"); + let span = span::expect().named("returns_impl_trait"); let (collector, handle) = collector::mock() .new_span( span.clone() - .with_field(field::mock("x").with_value(&10usize).only()), + .with_field(field::expect("x").with_value(&10usize).only()), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -179,13 +179,13 @@ fn err_dbg() -> Result { #[test] fn test_err_dbg() { - let span = span::mock().named("err_dbg"); + let span = span::expect().named("err_dbg"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock().at_level(Level::ERROR).with_fields( - field::mock("error") + event::expect().at_level(Level::ERROR).with_fields( + field::expect("error") // use the actual error value that will be emitted, so // that this test doesn't break if the standard library // changes the `fmt::Debug` output from the error type @@ -195,7 +195,7 @@ fn test_err_dbg() { ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || err_dbg().ok()); handle.assert_finished(); @@ -203,20 +203,20 @@ fn test_err_dbg() { #[test] fn test_err_display_default() { - let span = span::mock().named("err"); + let span = span::expect().named("err"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock().at_level(Level::ERROR).with_fields( - field::mock("error") + event::expect().at_level(Level::ERROR).with_fields( + field::expect("error") // by default, errors will be emitted with their display values .with_value(&tracing::field::display(u8::try_from(1234).unwrap_err())), ), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || err().ok()); handle.assert_finished(); @@ -225,19 +225,19 @@ fn test_err_display_default() { #[test] fn test_err_custom_target() { let filter: EnvFilter = "my_target=error".parse().expect("filter should parse"); - let span = span::mock().named("error_span").with_target("my_target"); + let span = span::expect().named("error_span").with_target("my_target"); let (subscriber, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() + event::expect() .at_level(Level::ERROR) .with_target("my_target"), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -260,14 +260,14 @@ fn err_info() -> Result { #[test] fn test_err_info() { - let span = span::mock().named("err_info"); + let span = span::expect().named("err_info"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::INFO)) + .event(event::expect().at_level(Level::INFO)) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || err_info().ok()); handle.assert_finished(); @@ -280,13 +280,13 @@ fn err_dbg_info() -> Result { #[test] fn test_err_dbg_info() { - let span = span::mock().named("err_dbg_info"); + let span = span::expect().named("err_dbg_info"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock().at_level(Level::INFO).with_fields( - field::mock("error") + event::expect().at_level(Level::INFO).with_fields( + field::expect("error") // use the actual error value that will be emitted, so // that this test doesn't break if the standard library // changes the `fmt::Debug` output from the error type @@ -296,7 +296,7 @@ fn test_err_dbg_info() { ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || err_dbg_info().ok()); handle.assert_finished(); @@ -309,14 +309,14 @@ fn err_warn_info() -> Result { #[test] fn test_err_warn_info() { - let span = span::mock().named("err_warn_info").at_level(Level::WARN); + let span = span::expect().named("err_warn_info").at_level(Level::WARN); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::INFO)) + .event(event::expect().at_level(Level::INFO)) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || err_warn_info().ok()); handle.assert_finished(); diff --git a/tracing-attributes/tests/fields.rs b/tracing-attributes/tests/fields.rs index 70649eea6b..63103751dd 100644 --- a/tracing-attributes/tests/fields.rs +++ b/tracing-attributes/tests/fields.rs @@ -1,6 +1,6 @@ use tracing::collect::with_default; use tracing_attributes::instrument; -use tracing_mock::field::mock; +use tracing_mock::field::expect; use tracing_mock::span::NewSpan; use tracing_mock::*; @@ -48,11 +48,11 @@ impl HasField { #[test] fn fields() { - let span = span::mock().with_field( - mock("foo") + let span = span::expect().with_field( + expect("foo") .with_value(&"bar") - .and(mock("dsa").with_value(&true)) - .and(mock("num").with_value(&1)) + .and(expect("dsa").with_value(&true)) + .and(expect("num").with_value(&1)) .only(), ); run_test(span, || { @@ -62,10 +62,10 @@ fn fields() { #[test] fn expr_field() { - let span = span::mock().with_field( - mock("s") + let span = span::expect().with_field( + expect("s") .with_value(&"hello world") - .and(mock("len").with_value(&"hello world".len())) + .and(expect("len").with_value(&"hello world".len())) .only(), ); run_test(span, || { @@ -75,11 +75,11 @@ fn expr_field() { #[test] fn two_expr_fields() { - let span = span::mock().with_field( - mock("s") + let span = span::expect().with_field( + expect("s") .with_value(&"hello world") - .and(mock("s.len").with_value(&"hello world".len())) - .and(mock("s.is_empty").with_value(&false)) + .and(expect("s.len").with_value(&"hello world".len())) + .and(expect("s.is_empty").with_value(&false)) .only(), ); run_test(span, || { @@ -89,19 +89,19 @@ fn two_expr_fields() { #[test] fn clashy_expr_field() { - let span = span::mock().with_field( + let span = span::expect().with_field( // Overriding the `s` field should record `s` as a `Display` value, // rather than as a `Debug` value. - mock("s") + expect("s") .with_value(&tracing::field::display("hello world")) - .and(mock("s.len").with_value(&"hello world".len())) + .and(expect("s.len").with_value(&"hello world".len())) .only(), ); run_test(span, || { fn_clashy_expr_field("hello world"); }); - let span = span::mock().with_field(mock("s").with_value(&"s").only()); + let span = span::expect().with_field(expect("s").with_value(&"s").only()); run_test(span, || { fn_clashy_expr_field2("hello world"); }); @@ -109,7 +109,7 @@ fn clashy_expr_field() { #[test] fn self_expr_field() { - let span = span::mock().with_field(mock("my_field").with_value(&"hello world").only()); + let span = span::expect().with_field(expect("my_field").with_value(&"hello world").only()); run_test(span, || { let has_field = HasField { my_field: "hello world", @@ -120,10 +120,10 @@ fn self_expr_field() { #[test] fn parameters_with_fields() { - let span = span::mock().with_field( - mock("foo") + let span = span::expect().with_field( + expect("foo") .with_value(&"bar") - .and(mock("param").with_value(&1u32)) + .and(expect("param").with_value(&1u32)) .only(), ); run_test(span, || { @@ -133,7 +133,7 @@ fn parameters_with_fields() { #[test] fn empty_field() { - let span = span::mock().with_field(mock("foo").with_value(&"bar").only()); + let span = span::expect().with_field(expect("foo").with_value(&"bar").only()); run_test(span, || { fn_empty_field(); }); @@ -141,7 +141,7 @@ fn empty_field() { #[test] fn string_field() { - let span = span::mock().with_field(mock("s").with_value(&"hello world").only()); + let span = span::expect().with_field(expect("s").with_value(&"hello world").only()); run_test(span, || { fn_string(String::from("hello world")); }); @@ -150,9 +150,9 @@ fn string_field() { fn run_test T, T>(span: NewSpan, fun: F) { let (collector, handle) = collector::mock() .new_span(span) - .enter(span::mock()) - .exit(span::mock()) - .done() + .enter(span::expect()) + .exit(span::expect()) + .only() .run_with_handle(); with_default(collector, fun); diff --git a/tracing-attributes/tests/follows_from.rs b/tracing-attributes/tests/follows_from.rs index bd4806af25..9862f3424d 100644 --- a/tracing-attributes/tests/follows_from.rs +++ b/tracing-attributes/tests/follows_from.rs @@ -13,10 +13,10 @@ fn follows_from_current() {} #[test] fn follows_from_sync_test() { - let cause_a = span::mock().named("cause_a"); - let cause_b = span::mock().named("cause_b"); - let cause_c = span::mock().named("cause_c"); - let consequence = span::mock().named("with_follows_from_sync"); + let cause_a = span::expect().named("cause_a"); + let cause_b = span::expect().named("cause_b"); + let cause_c = span::expect().named("cause_c"); + let consequence = span::expect().named("with_follows_from_sync"); let (collector, handle) = collector::mock() .new_span(cause_a.clone()) @@ -28,7 +28,7 @@ fn follows_from_sync_test() { .follows_from(consequence.clone(), cause_c) .enter(consequence.clone()) .exit(consequence) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -44,10 +44,10 @@ fn follows_from_sync_test() { #[test] fn follows_from_async_test() { - let cause_a = span::mock().named("cause_a"); - let cause_b = span::mock().named("cause_b"); - let cause_c = span::mock().named("cause_c"); - let consequence = span::mock().named("with_follows_from_async"); + let cause_a = span::expect().named("cause_a"); + let cause_b = span::expect().named("cause_b"); + let cause_c = span::expect().named("cause_c"); + let consequence = span::expect().named("with_follows_from_async"); let (collector, handle) = collector::mock() .new_span(cause_a.clone()) @@ -59,7 +59,7 @@ fn follows_from_async_test() { .follows_from(consequence.clone(), cause_c) .enter(consequence.clone()) .exit(consequence) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -77,8 +77,8 @@ fn follows_from_async_test() { #[test] fn follows_from_current_test() { - let cause = span::mock().named("cause"); - let consequence = span::mock().named("follows_from_current"); + let cause = span::expect().named("cause"); + let consequence = span::expect().named("follows_from_current"); let (collector, handle) = collector::mock() .new_span(cause.clone()) @@ -88,7 +88,7 @@ fn follows_from_current_test() { .enter(consequence.clone()) .exit(consequence) .exit(cause) - .done() + .only() .run_with_handle(); with_default(collector, || { diff --git a/tracing-attributes/tests/instrument.rs b/tracing-attributes/tests/instrument.rs index f91a1ce63a..341569ed70 100644 --- a/tracing-attributes/tests/instrument.rs +++ b/tracing-attributes/tests/instrument.rs @@ -20,11 +20,11 @@ fn override_everything() { #[instrument(level = Level::DEBUG, target = "my_target")] fn my_other_fn() {} - let span = span::mock() + let span = span::expect() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::mock() + let span2 = span::expect() .named("my_other_fn") .at_level(Level::DEBUG) .with_target("my_target"); @@ -37,7 +37,7 @@ fn override_everything() { .enter(span2.clone()) .exit(span2.clone()) .drop_span(span2) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -53,21 +53,21 @@ fn fields() { #[instrument(target = "my_target", level = "debug")] fn my_fn(arg1: usize, arg2: bool) {} - let span = span::mock() + let span = span::expect() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::mock() + let span2 = span::expect() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); let (collector, handle) = collector::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&2usize) - .and(field::mock("arg2").with_value(&false)) + .and(field::expect("arg2").with_value(&false)) .only(), ), ) @@ -76,16 +76,16 @@ fn fields() { .drop_span(span) .new_span( span2.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&3usize) - .and(field::mock("arg2").with_value(&true)) + .and(field::expect("arg2").with_value(&true)) .only(), ), ) .enter(span2.clone()) .exit(span2.clone()) .drop_span(span2) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -103,19 +103,19 @@ fn skip() { #[instrument(target = "my_target", level = "debug", skip(_arg2, _arg3))] fn my_fn(arg1: usize, _arg2: UnDebug, _arg3: UnDebug) {} - let span = span::mock() + let span = span::expect() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::mock() + let span2 = span::expect() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); let (collector, handle) = collector::mock() .new_span( span.clone() - .with_field(field::mock("arg1").with_value(&2usize).only()), + .with_field(field::expect("arg1").with_value(&2usize).only()), ) .enter(span.clone()) .exit(span.clone()) @@ -123,12 +123,12 @@ fn skip() { .new_span( span2 .clone() - .with_field(field::mock("arg1").with_value(&3usize).only()), + .with_field(field::expect("arg1").with_value(&3usize).only()), ) .enter(span2.clone()) .exit(span2.clone()) .drop_span(span2) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -151,20 +151,20 @@ fn generics() { { } - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (collector, handle) = collector::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("Foo")) - .and(field::mock("arg2").with_value(&format_args!("false"))), + .and(field::expect("arg2").with_value(&format_args!("false"))), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -184,20 +184,20 @@ fn methods() { fn my_fn(&self, arg1: usize) {} } - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (collector, handle) = collector::mock() .new_span( span.clone().with_field( - field::mock("self") + field::expect("self") .with_value(&format_args!("Foo")) - .and(field::mock("arg1").with_value(&42usize)), + .and(field::expect("arg1").with_value(&42usize)), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -215,17 +215,17 @@ fn impl_trait_return_type() { 0..x } - let span = span::mock().named("returns_impl_trait"); + let span = span::expect().named("returns_impl_trait"); let (collector, handle) = collector::mock() .new_span( span.clone() - .with_field(field::mock("x").with_value(&10usize).only()), + .with_field(field::expect("x").with_value(&10usize).only()), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || { diff --git a/tracing-attributes/tests/levels.rs b/tracing-attributes/tests/levels.rs index c0db05d8aa..e599b1a084 100644 --- a/tracing-attributes/tests/levels.rs +++ b/tracing-attributes/tests/levels.rs @@ -20,22 +20,22 @@ fn named_levels() { #[instrument(level = "eRrOr")] fn error() {} let (collector, handle) = collector::mock() - .new_span(span::mock().named("trace").at_level(Level::TRACE)) - .enter(span::mock().named("trace").at_level(Level::TRACE)) - .exit(span::mock().named("trace").at_level(Level::TRACE)) - .new_span(span::mock().named("debug").at_level(Level::DEBUG)) - .enter(span::mock().named("debug").at_level(Level::DEBUG)) - .exit(span::mock().named("debug").at_level(Level::DEBUG)) - .new_span(span::mock().named("info").at_level(Level::INFO)) - .enter(span::mock().named("info").at_level(Level::INFO)) - .exit(span::mock().named("info").at_level(Level::INFO)) - .new_span(span::mock().named("warn").at_level(Level::WARN)) - .enter(span::mock().named("warn").at_level(Level::WARN)) - .exit(span::mock().named("warn").at_level(Level::WARN)) - .new_span(span::mock().named("error").at_level(Level::ERROR)) - .enter(span::mock().named("error").at_level(Level::ERROR)) - .exit(span::mock().named("error").at_level(Level::ERROR)) - .done() + .new_span(span::expect().named("trace").at_level(Level::TRACE)) + .enter(span::expect().named("trace").at_level(Level::TRACE)) + .exit(span::expect().named("trace").at_level(Level::TRACE)) + .new_span(span::expect().named("debug").at_level(Level::DEBUG)) + .enter(span::expect().named("debug").at_level(Level::DEBUG)) + .exit(span::expect().named("debug").at_level(Level::DEBUG)) + .new_span(span::expect().named("info").at_level(Level::INFO)) + .enter(span::expect().named("info").at_level(Level::INFO)) + .exit(span::expect().named("info").at_level(Level::INFO)) + .new_span(span::expect().named("warn").at_level(Level::WARN)) + .enter(span::expect().named("warn").at_level(Level::WARN)) + .exit(span::expect().named("warn").at_level(Level::WARN)) + .new_span(span::expect().named("error").at_level(Level::ERROR)) + .enter(span::expect().named("error").at_level(Level::ERROR)) + .exit(span::expect().named("error").at_level(Level::ERROR)) + .only() .run_with_handle(); with_default(collector, || { @@ -66,22 +66,22 @@ fn numeric_levels() { #[instrument(level = 5)] fn error() {} let (collector, handle) = collector::mock() - .new_span(span::mock().named("trace").at_level(Level::TRACE)) - .enter(span::mock().named("trace").at_level(Level::TRACE)) - .exit(span::mock().named("trace").at_level(Level::TRACE)) - .new_span(span::mock().named("debug").at_level(Level::DEBUG)) - .enter(span::mock().named("debug").at_level(Level::DEBUG)) - .exit(span::mock().named("debug").at_level(Level::DEBUG)) - .new_span(span::mock().named("info").at_level(Level::INFO)) - .enter(span::mock().named("info").at_level(Level::INFO)) - .exit(span::mock().named("info").at_level(Level::INFO)) - .new_span(span::mock().named("warn").at_level(Level::WARN)) - .enter(span::mock().named("warn").at_level(Level::WARN)) - .exit(span::mock().named("warn").at_level(Level::WARN)) - .new_span(span::mock().named("error").at_level(Level::ERROR)) - .enter(span::mock().named("error").at_level(Level::ERROR)) - .exit(span::mock().named("error").at_level(Level::ERROR)) - .done() + .new_span(span::expect().named("trace").at_level(Level::TRACE)) + .enter(span::expect().named("trace").at_level(Level::TRACE)) + .exit(span::expect().named("trace").at_level(Level::TRACE)) + .new_span(span::expect().named("debug").at_level(Level::DEBUG)) + .enter(span::expect().named("debug").at_level(Level::DEBUG)) + .exit(span::expect().named("debug").at_level(Level::DEBUG)) + .new_span(span::expect().named("info").at_level(Level::INFO)) + .enter(span::expect().named("info").at_level(Level::INFO)) + .exit(span::expect().named("info").at_level(Level::INFO)) + .new_span(span::expect().named("warn").at_level(Level::WARN)) + .enter(span::expect().named("warn").at_level(Level::WARN)) + .exit(span::expect().named("warn").at_level(Level::WARN)) + .new_span(span::expect().named("error").at_level(Level::ERROR)) + .enter(span::expect().named("error").at_level(Level::ERROR)) + .exit(span::expect().named("error").at_level(Level::ERROR)) + .only() .run_with_handle(); with_default(collector, || { @@ -112,22 +112,22 @@ fn enum_levels() { #[instrument(level = Level::ERROR)] fn error() {} let (collector, handle) = collector::mock() - .new_span(span::mock().named("trace").at_level(Level::TRACE)) - .enter(span::mock().named("trace").at_level(Level::TRACE)) - .exit(span::mock().named("trace").at_level(Level::TRACE)) - .new_span(span::mock().named("debug").at_level(Level::DEBUG)) - .enter(span::mock().named("debug").at_level(Level::DEBUG)) - .exit(span::mock().named("debug").at_level(Level::DEBUG)) - .new_span(span::mock().named("info").at_level(Level::INFO)) - .enter(span::mock().named("info").at_level(Level::INFO)) - .exit(span::mock().named("info").at_level(Level::INFO)) - .new_span(span::mock().named("warn").at_level(Level::WARN)) - .enter(span::mock().named("warn").at_level(Level::WARN)) - .exit(span::mock().named("warn").at_level(Level::WARN)) - .new_span(span::mock().named("error").at_level(Level::ERROR)) - .enter(span::mock().named("error").at_level(Level::ERROR)) - .exit(span::mock().named("error").at_level(Level::ERROR)) - .done() + .new_span(span::expect().named("trace").at_level(Level::TRACE)) + .enter(span::expect().named("trace").at_level(Level::TRACE)) + .exit(span::expect().named("trace").at_level(Level::TRACE)) + .new_span(span::expect().named("debug").at_level(Level::DEBUG)) + .enter(span::expect().named("debug").at_level(Level::DEBUG)) + .exit(span::expect().named("debug").at_level(Level::DEBUG)) + .new_span(span::expect().named("info").at_level(Level::INFO)) + .enter(span::expect().named("info").at_level(Level::INFO)) + .exit(span::expect().named("info").at_level(Level::INFO)) + .new_span(span::expect().named("warn").at_level(Level::WARN)) + .enter(span::expect().named("warn").at_level(Level::WARN)) + .exit(span::expect().named("warn").at_level(Level::WARN)) + .new_span(span::expect().named("error").at_level(Level::ERROR)) + .enter(span::expect().named("error").at_level(Level::ERROR)) + .exit(span::expect().named("error").at_level(Level::ERROR)) + .only() .run_with_handle(); with_default(collector, || { diff --git a/tracing-attributes/tests/names.rs b/tracing-attributes/tests/names.rs index f97a747e4f..94f4604a87 100644 --- a/tracing-attributes/tests/names.rs +++ b/tracing-attributes/tests/names.rs @@ -17,10 +17,10 @@ fn custom_name_no_equals() {} #[test] fn default_name_test() { let (collector, handle) = collector::mock() - .new_span(span::mock().named("default_name")) - .enter(span::mock().named("default_name")) - .exit(span::mock().named("default_name")) - .done() + .new_span(span::expect().named("default_name")) + .enter(span::expect().named("default_name")) + .exit(span::expect().named("default_name")) + .only() .run_with_handle(); with_default(collector, || { @@ -33,10 +33,10 @@ fn default_name_test() { #[test] fn custom_name_test() { let (collector, handle) = collector::mock() - .new_span(span::mock().named("my_name")) - .enter(span::mock().named("my_name")) - .exit(span::mock().named("my_name")) - .done() + .new_span(span::expect().named("my_name")) + .enter(span::expect().named("my_name")) + .exit(span::expect().named("my_name")) + .only() .run_with_handle(); with_default(collector, || { @@ -49,10 +49,10 @@ fn custom_name_test() { #[test] fn custom_name_no_equals_test() { let (collector, handle) = collector::mock() - .new_span(span::mock().named("my_other_name")) - .enter(span::mock().named("my_other_name")) - .exit(span::mock().named("my_other_name")) - .done() + .new_span(span::expect().named("my_other_name")) + .enter(span::expect().named("my_other_name")) + .exit(span::expect().named("my_other_name")) + .only() .run_with_handle(); with_default(collector, || { diff --git a/tracing-attributes/tests/parents.rs b/tracing-attributes/tests/parents.rs index c4d375f530..515dafb73d 100644 --- a/tracing-attributes/tests/parents.rs +++ b/tracing-attributes/tests/parents.rs @@ -14,8 +14,8 @@ where #[test] fn default_parent_test() { - let contextual_parent = span::mock().named("contextual_parent"); - let child = span::mock().named("with_default_parent"); + let contextual_parent = span::expect().named("contextual_parent"); + let child = span::expect().named("with_default_parent"); let (collector, handle) = collector::mock() .new_span( @@ -42,7 +42,7 @@ fn default_parent_test() { .enter(child.clone()) .exit(child) .exit(contextual_parent) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -60,9 +60,9 @@ fn default_parent_test() { #[test] fn explicit_parent_test() { - let contextual_parent = span::mock().named("contextual_parent"); - let explicit_parent = span::mock().named("explicit_parent"); - let child = span::mock().named("with_explicit_parent"); + let contextual_parent = span::expect().named("contextual_parent"); + let explicit_parent = span::expect().named("explicit_parent"); + let child = span::expect().named("with_explicit_parent"); let (collector, handle) = collector::mock() .new_span( @@ -86,7 +86,7 @@ fn explicit_parent_test() { .enter(child.clone()) .exit(child) .exit(contextual_parent) - .done() + .only() .run_with_handle(); with_default(collector, || { diff --git a/tracing-attributes/tests/ret.rs b/tracing-attributes/tests/ret.rs index 2511e0a520..1e8c17bf02 100644 --- a/tracing-attributes/tests/ret.rs +++ b/tracing-attributes/tests/ret.rs @@ -19,18 +19,18 @@ fn ret_with_target() -> i32 { #[test] fn test() { - let span = span::mock().named("ret"); + let span = span::expect().named("ret"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, ret); @@ -40,7 +40,7 @@ fn test() { #[test] fn test_custom_target() { let filter: EnvFilter = "my_target=info".parse().expect("filter should parse"); - let span = span::mock() + let span = span::expect() .named("ret_with_target") .with_target("my_target"); @@ -48,14 +48,14 @@ fn test_custom_target() { .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO) .with_target("my_target"), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -71,18 +71,18 @@ fn ret_warn() -> i32 { #[test] fn test_warn() { - let span = span::mock().named("ret_warn"); + let span = span::expect().named("ret_warn"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::WARN), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, ret_warn); @@ -98,23 +98,23 @@ fn ret_mut(a: &mut i32) -> i32 { #[test] fn test_mut() { - let span = span::mock().named("ret_mut"); + let span = span::expect().named("ret_mut"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("a").with_value(&tracing::field::display(2))) + event::expect() + .with_fields(field::expect("a").with_value(&tracing::field::display(2))) .at_level(Level::INFO), ) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(2))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(2))) .at_level(Level::INFO), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || ret_mut(&mut 1)); @@ -128,18 +128,18 @@ async fn ret_async() -> i32 { #[test] fn test_async() { - let span = span::mock().named("ret_async"); + let span = span::expect().named("ret_async"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || block_on_future(async { ret_async().await })); @@ -153,18 +153,18 @@ fn ret_impl_type() -> impl Copy { #[test] fn test_impl_type() { - let span = span::mock().named("ret_impl_type"); + let span = span::expect().named("ret_impl_type"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, ret_impl_type); @@ -178,18 +178,18 @@ fn ret_display() -> i32 { #[test] fn test_dbg() { - let span = span::mock().named("ret_display"); + let span = span::expect().named("ret_display"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::display(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::display(42))) .at_level(Level::INFO), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, ret_display); @@ -203,14 +203,14 @@ fn ret_and_err() -> Result { #[test] fn test_ret_and_err() { - let span = span::mock().named("ret_and_err"); + let span = span::expect().named("ret_and_err"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() + event::expect() .with_fields( - field::mock("error") + field::expect("error") .with_value(&tracing::field::display(u8::try_from(1234).unwrap_err())) .only(), ) @@ -218,7 +218,7 @@ fn test_ret_and_err() { ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || ret_and_err().ok()); @@ -232,14 +232,14 @@ fn ret_and_ok() -> Result { #[test] fn test_ret_and_ok() { - let span = span::mock().named("ret_and_ok"); + let span = span::expect().named("ret_and_ok"); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() + event::expect() .with_fields( - field::mock("return") + field::expect("return") .with_value(&tracing::field::debug(u8::try_from(123).unwrap())) .only(), ) @@ -247,7 +247,7 @@ fn test_ret_and_ok() { ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, || ret_and_ok().ok()); @@ -261,18 +261,18 @@ fn ret_warn_info() -> i32 { #[test] fn test_warn_info() { - let span = span::mock().named("ret_warn_info").at_level(Level::WARN); + let span = span::expect().named("ret_warn_info").at_level(Level::WARN); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, ret_warn_info); @@ -286,18 +286,18 @@ fn ret_dbg_warn() -> i32 { #[test] fn test_dbg_warn() { - let span = span::mock().named("ret_dbg_warn").at_level(Level::INFO); + let span = span::expect().named("ret_dbg_warn").at_level(Level::INFO); let (collector, handle) = collector::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::WARN), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(collector, ret_dbg_warn); diff --git a/tracing-attributes/tests/targets.rs b/tracing-attributes/tests/targets.rs index ba476611aa..6fef8ab2ed 100644 --- a/tracing-attributes/tests/targets.rs +++ b/tracing-attributes/tests/targets.rs @@ -24,36 +24,36 @@ mod my_mod { fn default_targets() { let (collector, handle) = collector::mock() .new_span( - span::mock() + span::expect() .named("default_target") .with_target(module_path!()), ) .enter( - span::mock() + span::expect() .named("default_target") .with_target(module_path!()), ) .exit( - span::mock() + span::expect() .named("default_target") .with_target(module_path!()), ) .new_span( - span::mock() + span::expect() .named("default_target") .with_target(my_mod::MODULE_PATH), ) .enter( - span::mock() + span::expect() .named("default_target") .with_target(my_mod::MODULE_PATH), ) .exit( - span::mock() + span::expect() .named("default_target") .with_target(my_mod::MODULE_PATH), ) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -67,25 +67,37 @@ fn default_targets() { #[test] fn custom_targets() { let (collector, handle) = collector::mock() - .new_span(span::mock().named("custom_target").with_target("my_target")) - .enter(span::mock().named("custom_target").with_target("my_target")) - .exit(span::mock().named("custom_target").with_target("my_target")) .new_span( - span::mock() + span::expect() + .named("custom_target") + .with_target("my_target"), + ) + .enter( + span::expect() + .named("custom_target") + .with_target("my_target"), + ) + .exit( + span::expect() + .named("custom_target") + .with_target("my_target"), + ) + .new_span( + span::expect() .named("custom_target") .with_target("my_other_target"), ) .enter( - span::mock() + span::expect() .named("custom_target") .with_target("my_other_target"), ) .exit( - span::mock() + span::expect() .named("custom_target") .with_target("my_other_target"), ) - .done() + .only() .run_with_handle(); with_default(collector, || { diff --git a/tracing-futures/src/lib.rs b/tracing-futures/src/lib.rs index a2aa677655..30d0ff951d 100644 --- a/tracing-futures/src/lib.rs +++ b/tracing-futures/src/lib.rs @@ -567,12 +567,12 @@ mod tests { #[test] fn future_enter_exit_is_reasonable() { let (collector, handle) = collector::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { PollN::new_ok(2) @@ -586,12 +586,12 @@ mod tests { #[test] fn future_error_ends_span() { let (collector, handle) = collector::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { PollN::new_err(2) @@ -606,15 +606,15 @@ mod tests { #[test] fn stream_enter_exit_is_reasonable() { let (collector, handle) = collector::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .run_with_handle(); with_default(collector, || { stream::iter_ok::<_, ()>(&[1, 2, 3]) @@ -637,7 +637,7 @@ mod tests { // .drop_span(span::mock().named("b")) // .exit(span::mock().named("a")) // .drop_span(span::mock().named("a")) - // .done() + // .only() // .run_with_handle(); // let mut runtime = tokio::runtime::Runtime::new().unwrap(); // with_default(collector, || { @@ -667,15 +667,15 @@ mod tests { #[test] fn stream_enter_exit_is_reasonable() { let (collector, handle) = collector::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .run_with_handle(); with_default(collector, || { Instrument::instrument(stream::iter(&[1, 2, 3]), tracing::trace_span!("foo")) @@ -689,13 +689,13 @@ mod tests { #[test] fn sink_enter_exit_is_reasonable() { let (collector, handle) = collector::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .run_with_handle(); with_default(collector, || { 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 7242320191..c767c13891 100644 --- a/tracing-futures/tests/std_future.rs +++ b/tracing-futures/tests/std_future.rs @@ -5,12 +5,12 @@ use tracing_mock::*; #[test] fn enter_exit_is_reasonable() { let (collector, handle) = collector::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { let future = PollN::new_ok(2).instrument(tracing::span!(Level::TRACE, "foo")); @@ -22,12 +22,12 @@ fn enter_exit_is_reasonable() { #[test] fn error_ends_span() { let (collector, handle) = collector::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { let future = PollN::new_err(2).instrument(tracing::span!(Level::TRACE, "foo")); diff --git a/tracing-mock/src/collector.rs b/tracing-mock/src/collector.rs index f60918f7d0..4d8b5f7ad8 100644 --- a/tracing-mock/src/collector.rs +++ b/tracing-mock/src/collector.rs @@ -1,9 +1,9 @@ #![allow(missing_docs)] use crate::{ - event::MockEvent, + event::ExpectedEvent, expectation::Expect, - field as mock_field, - span::{MockSpan, NewSpan}, + field::ExpectedFields, + span::{ExpectedSpan, NewSpan}, }; use std::{ collections::{HashMap, VecDeque}, @@ -82,46 +82,46 @@ where } } - pub fn enter(mut self, span: MockSpan) -> Self { + pub fn enter(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::Enter(span)); self } - pub fn follows_from(mut self, consequence: MockSpan, cause: MockSpan) -> Self { + pub fn follows_from(mut self, consequence: ExpectedSpan, cause: ExpectedSpan) -> Self { self.expected .push_back(Expect::FollowsFrom { consequence, cause }); self } - pub fn event(mut self, event: MockEvent) -> Self { + pub fn event(mut self, event: ExpectedEvent) -> Self { self.expected.push_back(Expect::Event(event)); self } - pub fn exit(mut self, span: MockSpan) -> Self { + pub fn exit(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::Exit(span)); self } - pub fn clone_span(mut self, span: MockSpan) -> Self { + pub fn clone_span(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::CloneSpan(span)); self } #[allow(deprecated)] - pub fn drop_span(mut self, span: MockSpan) -> Self { + pub fn drop_span(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::DropSpan(span)); self } - pub fn done(mut self) -> Self { + pub fn only(mut self) -> Self { self.expected.push_back(Expect::Nothing); self } - pub fn record(mut self, span: MockSpan, fields: I) -> Self + pub fn record(mut self, span: ExpectedSpan, fields: I) -> Self where - I: Into, + I: Into, { self.expected.push_back(Expect::Visit(span, fields.into())); self diff --git a/tracing-mock/src/event.rs b/tracing-mock/src/event.rs index d16f276678..2668fcd81a 100644 --- a/tracing-mock/src/event.rs +++ b/tracing-mock/src/event.rs @@ -1,5 +1,5 @@ #![allow(missing_docs)] -use super::{field, metadata, span, Parent}; +use super::{field, metadata::ExpectedMetadata, span, Parent}; use std::fmt; @@ -8,30 +8,30 @@ use std::fmt; /// This is intended for use with the mock subscriber API in the /// `subscriber` module. #[derive(Default, Eq, PartialEq)] -pub struct MockEvent { - pub fields: Option, - pub(crate) parent: Option, - in_spans: Vec, - metadata: metadata::Expect, +pub struct ExpectedEvent { + fields: Option, + parent: Option, + in_spans: Vec, + metadata: ExpectedMetadata, } -pub fn mock() -> MockEvent { - MockEvent { +pub fn expect() -> ExpectedEvent { + ExpectedEvent { ..Default::default() } } -pub fn msg(message: impl fmt::Display) -> MockEvent { - mock().with_fields(field::msg(message)) +pub fn msg(message: impl fmt::Display) -> ExpectedEvent { + expect().with_fields(field::msg(message)) } -impl MockEvent { +impl ExpectedEvent { pub fn named(self, name: I) -> Self where I: Into, { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { name: Some(name.into()), ..self.metadata }, @@ -41,7 +41,7 @@ impl MockEvent { pub fn with_fields(self, fields: I) -> Self where - I: Into, + I: Into, { Self { fields: Some(fields.into()), @@ -51,7 +51,7 @@ impl MockEvent { pub fn at_level(self, level: tracing::Level) -> Self { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { level: Some(level), ..self.metadata }, @@ -64,7 +64,7 @@ impl MockEvent { I: Into, { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { target: Some(target.into()), ..self.metadata }, @@ -72,7 +72,7 @@ impl MockEvent { } } - pub fn with_explicit_parent(self, parent: Option<&str>) -> MockEvent { + pub fn with_explicit_parent(self, parent: Option<&str>) -> ExpectedEvent { let parent = match parent { Some(name) => Parent::Explicit(name.into()), None => Parent::ExplicitRoot, @@ -117,25 +117,25 @@ impl MockEvent { } } - pub fn in_scope(self, spans: impl IntoIterator) -> Self { + pub fn in_scope(self, spans: impl IntoIterator) -> Self { Self { in_spans: spans.into_iter().collect(), ..self } } - pub fn scope_mut(&mut self) -> &mut [span::MockSpan] { + pub fn scope_mut(&mut self) -> &mut [span::ExpectedSpan] { &mut self.in_spans[..] } } -impl fmt::Display for MockEvent { +impl fmt::Display for ExpectedEvent { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "an event{}", self.metadata) } } -impl fmt::Debug for MockEvent { +impl fmt::Debug for ExpectedEvent { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut s = f.debug_struct("MockEvent"); diff --git a/tracing-mock/src/expectation.rs b/tracing-mock/src/expectation.rs index 0328754fc8..cd48728ae7 100644 --- a/tracing-mock/src/expectation.rs +++ b/tracing-mock/src/expectation.rs @@ -1,21 +1,21 @@ use crate::{ - event::MockEvent, - field, - span::{MockSpan, NewSpan}, + event::ExpectedEvent, + field::ExpectedFields, + span::{ExpectedSpan, NewSpan}, }; #[derive(Debug, Eq, PartialEq)] pub(crate) enum Expect { - Event(MockEvent), + Event(ExpectedEvent), FollowsFrom { - consequence: MockSpan, - cause: MockSpan, + consequence: ExpectedSpan, + cause: ExpectedSpan, }, - Enter(MockSpan), - Exit(MockSpan), - CloneSpan(MockSpan), - DropSpan(MockSpan), - Visit(MockSpan, field::Expect), + Enter(ExpectedSpan), + Exit(ExpectedSpan), + CloneSpan(ExpectedSpan), + DropSpan(ExpectedSpan), + Visit(ExpectedSpan, ExpectedFields), NewSpan(NewSpan), Nothing, } diff --git a/tracing-mock/src/field.rs b/tracing-mock/src/field.rs index 45a17bfa29..51198c7dcb 100644 --- a/tracing-mock/src/field.rs +++ b/tracing-mock/src/field.rs @@ -8,19 +8,19 @@ use tracing::{ use std::{collections::HashMap, fmt}; #[derive(Default, Debug, Eq, PartialEq)] -pub struct Expect { - fields: HashMap, +pub struct ExpectedFields { + fields: HashMap, only: bool, } #[derive(Debug)] -pub struct MockField { +pub struct ExpectedField { name: String, - value: MockValue, + value: ExpectedValue, } #[derive(Debug)] -pub enum MockValue { +pub enum ExpectedValue { F64(f64), I64(i64), U64(u64), @@ -30,11 +30,11 @@ pub enum MockValue { Any, } -impl Eq for MockValue {} +impl Eq for ExpectedValue {} -impl PartialEq for MockValue { +impl PartialEq for ExpectedValue { fn eq(&self, other: &Self) -> bool { - use MockValue::*; + use ExpectedValue::*; match (self, other) { (F64(a), F64(b)) => { @@ -55,34 +55,34 @@ impl PartialEq for MockValue { } } -pub fn mock(name: K) -> MockField +pub fn expect(name: K) -> ExpectedField where String: From, { - MockField { + ExpectedField { name: name.into(), - value: MockValue::Any, + value: ExpectedValue::Any, } } -pub fn msg(message: impl fmt::Display) -> MockField { - MockField { +pub fn msg(message: impl fmt::Display) -> ExpectedField { + ExpectedField { name: "message".to_string(), - value: MockValue::Debug(message.to_string()), + value: ExpectedValue::Debug(message.to_string()), } } -impl MockField { +impl ExpectedField { /// Expect a field with the given name and value. pub fn with_value(self, value: &dyn Value) -> Self { Self { - value: MockValue::from(value), + value: ExpectedValue::from(value), ..self } } - pub fn and(self, other: MockField) -> Expect { - Expect { + pub fn and(self, other: ExpectedField) -> ExpectedFields { + ExpectedFields { fields: HashMap::new(), only: false, } @@ -90,8 +90,8 @@ impl MockField { .and(other) } - pub fn only(self) -> Expect { - Expect { + pub fn only(self) -> ExpectedFields { + ExpectedFields { fields: HashMap::new(), only: true, } @@ -99,9 +99,9 @@ impl MockField { } } -impl From for Expect { - fn from(field: MockField) -> Self { - Expect { +impl From for ExpectedFields { + fn from(field: ExpectedField) -> Self { + ExpectedFields { fields: HashMap::new(), only: false, } @@ -109,8 +109,8 @@ impl From for Expect { } } -impl Expect { - pub fn and(mut self, field: MockField) -> Self { +impl ExpectedFields { + pub fn and(mut self, field: ExpectedField) -> Self { self.fields.insert(field.name, field.value); self } @@ -123,7 +123,7 @@ impl Expect { fn compare_or_panic(&mut self, name: &str, value: &dyn Value, ctx: &str, collector_name: &str) { let value = value.into(); match self.fields.remove(name) { - Some(MockValue::Any) => {} + Some(ExpectedValue::Any) => {} Some(expected) => assert!( expected == value, "\n[{}] expected `{}` to contain:\n\t`{}{}`\nbut got:\n\t`{}{}`", @@ -155,22 +155,22 @@ impl Expect { } } -impl fmt::Display for MockValue { +impl fmt::Display for ExpectedValue { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { - MockValue::F64(v) => write!(f, "f64 = {:?}", v), - MockValue::I64(v) => write!(f, "i64 = {:?}", v), - MockValue::U64(v) => write!(f, "u64 = {:?}", v), - MockValue::Bool(v) => write!(f, "bool = {:?}", v), - MockValue::Str(v) => write!(f, "&str = {:?}", v), - MockValue::Debug(v) => write!(f, "&fmt::Debug = {:?}", v), - MockValue::Any => write!(f, "_ = _"), + ExpectedValue::F64(v) => write!(f, "f64 = {:?}", v), + ExpectedValue::I64(v) => write!(f, "i64 = {:?}", v), + ExpectedValue::U64(v) => write!(f, "u64 = {:?}", v), + ExpectedValue::Bool(v) => write!(f, "bool = {:?}", v), + ExpectedValue::Str(v) => write!(f, "&str = {:?}", v), + ExpectedValue::Debug(v) => write!(f, "&fmt::Debug = {:?}", v), + ExpectedValue::Any => write!(f, "_ = _"), } } } pub struct CheckVisitor<'a> { - expect: &'a mut Expect, + expect: &'a mut ExpectedFields, ctx: &'a str, collector_name: &'a str, } @@ -223,35 +223,35 @@ impl<'a> CheckVisitor<'a> { } } -impl<'a> From<&'a dyn Value> for MockValue { +impl<'a> From<&'a dyn Value> for ExpectedValue { fn from(value: &'a dyn Value) -> Self { struct MockValueBuilder { - value: Option, + value: Option, } impl Visit for MockValueBuilder { fn record_f64(&mut self, _: &Field, value: f64) { - self.value = Some(MockValue::F64(value)); + self.value = Some(ExpectedValue::F64(value)); } fn record_i64(&mut self, _: &Field, value: i64) { - self.value = Some(MockValue::I64(value)); + self.value = Some(ExpectedValue::I64(value)); } fn record_u64(&mut self, _: &Field, value: u64) { - self.value = Some(MockValue::U64(value)); + self.value = Some(ExpectedValue::U64(value)); } fn record_bool(&mut self, _: &Field, value: bool) { - self.value = Some(MockValue::Bool(value)); + self.value = Some(ExpectedValue::Bool(value)); } fn record_str(&mut self, _: &Field, value: &str) { - self.value = Some(MockValue::Str(value.to_owned())); + self.value = Some(ExpectedValue::Str(value.to_owned())); } fn record_debug(&mut self, _: &Field, value: &dyn fmt::Debug) { - self.value = Some(MockValue::Debug(format!("{:?}", value))); + self.value = Some(ExpectedValue::Debug(format!("{:?}", value))); } } @@ -268,7 +268,7 @@ impl<'a> From<&'a dyn Value> for MockValue { } } -impl fmt::Display for Expect { +impl fmt::Display for ExpectedFields { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "fields ")?; let entries = self diff --git a/tracing-mock/src/metadata.rs b/tracing-mock/src/metadata.rs index 6655e32caf..9d2d341145 100644 --- a/tracing-mock/src/metadata.rs +++ b/tracing-mock/src/metadata.rs @@ -2,13 +2,13 @@ use std::fmt; use tracing_core::Metadata; #[derive(Clone, Debug, Eq, PartialEq, Default)] -pub struct Expect { - pub name: Option, - pub level: Option, - pub target: Option, +pub(crate) struct ExpectedMetadata { + pub(crate) name: Option, + pub(crate) level: Option, + pub(crate) target: Option, } -impl Expect { +impl ExpectedMetadata { pub(crate) fn check( &self, actual: &Metadata<'_>, @@ -53,7 +53,7 @@ impl Expect { } } -impl fmt::Display for Expect { +impl fmt::Display for ExpectedMetadata { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if let Some(ref name) = self.name { write!(f, " named `{}`", name)?; diff --git a/tracing-mock/src/span.rs b/tracing-mock/src/span.rs index 2fde98f163..a294d82c4f 100644 --- a/tracing-mock/src/span.rs +++ b/tracing-mock/src/span.rs @@ -1,5 +1,5 @@ #![allow(missing_docs)] -use super::{field, metadata, Parent}; +use super::{field::ExpectedFields, metadata::ExpectedMetadata, Parent}; use std::fmt; /// A mock span. @@ -7,37 +7,37 @@ use std::fmt; /// This is intended for use with the mock subscriber API in the /// `subscriber` module. #[derive(Clone, Default, Eq, PartialEq)] -pub struct MockSpan { - pub(crate) metadata: metadata::Expect, +pub struct ExpectedSpan { + pub(crate) metadata: ExpectedMetadata, } #[derive(Default, Eq, PartialEq)] pub struct NewSpan { - pub(crate) span: MockSpan, - pub(crate) fields: field::Expect, + pub(crate) span: ExpectedSpan, + pub(crate) fields: ExpectedFields, pub(crate) parent: Option, } -pub fn mock() -> MockSpan { - MockSpan { +pub fn expect() -> ExpectedSpan { + ExpectedSpan { ..Default::default() } } -pub fn named(name: I) -> MockSpan +pub fn named(name: I) -> ExpectedSpan where I: Into, { - mock().named(name) + expect().named(name) } -impl MockSpan { +impl ExpectedSpan { pub fn named(self, name: I) -> Self where I: Into, { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { name: Some(name.into()), ..self.metadata }, @@ -46,7 +46,7 @@ impl MockSpan { pub fn at_level(self, level: tracing::Level) -> Self { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { level: Some(level), ..self.metadata }, @@ -58,7 +58,7 @@ impl MockSpan { I: Into, { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { target: Some(target.into()), ..self.metadata }, @@ -103,7 +103,7 @@ impl MockSpan { pub fn with_field(self, fields: I) -> NewSpan where - I: Into, + I: Into, { NewSpan { span: self, @@ -113,7 +113,7 @@ impl MockSpan { } } -impl fmt::Debug for MockSpan { +impl fmt::Debug for ExpectedSpan { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut s = f.debug_struct("MockSpan"); @@ -133,7 +133,7 @@ impl fmt::Debug for MockSpan { } } -impl fmt::Display for MockSpan { +impl fmt::Display for ExpectedSpan { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if self.metadata.name.is_some() { write!(f, "a span{}", self.metadata) @@ -143,8 +143,8 @@ impl fmt::Display for MockSpan { } } -impl From for NewSpan { - fn from(span: MockSpan) -> Self { +impl From for NewSpan { + fn from(span: ExpectedSpan) -> Self { Self { span, ..Default::default() @@ -177,7 +177,7 @@ impl NewSpan { pub fn with_field(self, fields: I) -> NewSpan where - I: Into, + I: Into, { NewSpan { fields: fields.into(), diff --git a/tracing-mock/src/subscriber.rs b/tracing-mock/src/subscriber.rs index d744cc6a02..f08b174ad3 100644 --- a/tracing-mock/src/subscriber.rs +++ b/tracing-mock/src/subscriber.rs @@ -1,10 +1,10 @@ #![allow(missing_docs, dead_code)] use crate::{ collector::MockHandle, - event::MockEvent, + event::ExpectedEvent, expectation::Expect, - field, - span::{MockSpan, NewSpan}, + field::ExpectedFields, + span::{ExpectedSpan, NewSpan}, }; use tracing_core::{ span::{Attributes, Id, Record}, @@ -21,8 +21,8 @@ use std::{ sync::{Arc, Mutex}, }; -pub fn mock() -> ExpectSubscriberBuilder { - ExpectSubscriberBuilder { +pub fn mock() -> MockSubscriberBuilder { + MockSubscriberBuilder { expected: Default::default(), name: std::thread::current() .name() @@ -31,22 +31,22 @@ pub fn mock() -> ExpectSubscriberBuilder { } } -pub fn named(name: impl std::fmt::Display) -> ExpectSubscriberBuilder { +pub fn named(name: impl std::fmt::Display) -> MockSubscriberBuilder { mock().named(name) } -pub struct ExpectSubscriberBuilder { +pub struct MockSubscriberBuilder { expected: VecDeque, name: String, } -pub struct ExpectSubscriber { +pub struct MockSubscriber { expected: Arc>>, current: Mutex>, name: String, } -impl ExpectSubscriberBuilder { +impl MockSubscriberBuilder { /// Overrides the name printed by the mock subscriber's debugging output. /// /// The debugging output is displayed if the test panics, or if the test is @@ -70,29 +70,29 @@ impl ExpectSubscriberBuilder { self } - pub fn enter(mut self, span: MockSpan) -> Self { + pub fn enter(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::Enter(span)); self } - pub fn event(mut self, event: MockEvent) -> Self { + pub fn event(mut self, event: ExpectedEvent) -> Self { self.expected.push_back(Expect::Event(event)); self } - pub fn exit(mut self, span: MockSpan) -> Self { + pub fn exit(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::Exit(span)); self } - pub fn done(mut self) -> Self { + pub fn only(mut self) -> Self { self.expected.push_back(Expect::Nothing); self } - pub fn record(mut self, span: MockSpan, fields: I) -> Self + pub fn record(mut self, span: ExpectedSpan, fields: I) -> Self where - I: Into, + I: Into, { self.expected.push_back(Expect::Visit(span, fields.into())); self @@ -106,18 +106,18 @@ impl ExpectSubscriberBuilder { self } - pub fn run(self) -> ExpectSubscriber { - ExpectSubscriber { + pub fn run(self) -> MockSubscriber { + MockSubscriber { expected: Arc::new(Mutex::new(self.expected)), name: self.name, current: Mutex::new(Vec::new()), } } - pub fn run_with_handle(self) -> (ExpectSubscriber, MockHandle) { + pub fn run_with_handle(self) -> (MockSubscriber, MockHandle) { let expected = Arc::new(Mutex::new(self.expected)); let handle = MockHandle::new(expected.clone(), self.name.clone()); - let subscriber = ExpectSubscriber { + let subscriber = MockSubscriber { expected, name: self.name, current: Mutex::new(Vec::new()), @@ -126,10 +126,10 @@ impl ExpectSubscriberBuilder { } } -impl ExpectSubscriber { +impl MockSubscriber { fn check_span_ref<'spans, S>( &self, - expected: &MockSpan, + expected: &ExpectedSpan, actual: &SpanRef<'spans, S>, what_happened: impl fmt::Display, ) where @@ -187,7 +187,7 @@ impl ExpectSubscriber { } } -impl Subscribe for ExpectSubscriber +impl Subscribe for MockSubscriber where C: Collect + for<'a> LookupSpan<'a>, { @@ -381,7 +381,7 @@ where } } -impl fmt::Debug for ExpectSubscriber { +impl fmt::Debug for MockSubscriber { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut s = f.debug_struct("ExpectSubscriber"); s.field("name", &self.name); diff --git a/tracing-subscriber/tests/cached_subscriber_filters_dont_break_other_subscribers.rs b/tracing-subscriber/tests/cached_subscriber_filters_dont_break_other_subscribers.rs index dcb32d119b..d0ac9cd877 100644 --- a/tracing-subscriber/tests/cached_subscriber_filters_dont_break_other_subscribers.rs +++ b/tracing-subscriber/tests/cached_subscriber_filters_dont_break_other_subscribers.rs @@ -2,7 +2,7 @@ use tracing::Level; use tracing_mock::{ collector, event, - subscriber::{self, ExpectSubscriber}, + subscriber::{self, MockSubscriber}, }; use tracing_subscriber::{filter::LevelFilter, prelude::*}; @@ -104,22 +104,22 @@ fn filter() -> LevelFilter { LevelFilter::INFO } -fn unfiltered(name: &str) -> (ExpectSubscriber, collector::MockHandle) { +fn unfiltered(name: &str) -> (MockSubscriber, collector::MockHandle) { subscriber::named(name) - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } -fn filtered(name: &str) -> (ExpectSubscriber, collector::MockHandle) { +fn filtered(name: &str) -> (MockSubscriber, collector::MockHandle) { subscriber::named(name) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } diff --git a/tracing-subscriber/tests/env_filter/main.rs b/tracing-subscriber/tests/env_filter/main.rs index 2246d92ebd..bfdeab00c9 100644 --- a/tracing-subscriber/tests/env_filter/main.rs +++ b/tracing-subscriber/tests/env_filter/main.rs @@ -13,10 +13,10 @@ use tracing_subscriber::{ fn level_filter_event() { let filter: EnvFilter = "info".parse().expect("filter should parse"); let (subscriber, finished) = collector::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -38,18 +38,18 @@ fn same_name_spans() { .expect("filter should parse"); let (subscriber, finished) = collector::mock() .new_span( - span::mock() + span::expect() .named("foo") .at_level(Level::TRACE) - .with_field(field::mock("bar")), + .with_field(field::expect("bar")), ) .new_span( - span::mock() + span::expect() .named("foo") .at_level(Level::TRACE) - .with_field(field::mock("baz")), + .with_field(field::expect("baz")), ) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); with_default(subscriber, || { @@ -64,12 +64,12 @@ fn same_name_spans() { fn level_filter_event_with_target() { let filter: EnvFilter = "info,stuff=debug".parse().expect("filter should parse"); let (subscriber, finished) = collector::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG).with_target("stuff")) - .event(event::mock().at_level(Level::WARN).with_target("stuff")) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::ERROR).with_target("stuff")) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) + .event(event::expect().at_level(Level::WARN).with_target("stuff")) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -93,12 +93,12 @@ fn not_order_dependent() { let filter: EnvFilter = "stuff=debug,info".parse().expect("filter should parse"); let (subscriber, finished) = collector::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG).with_target("stuff")) - .event(event::mock().at_level(Level::WARN).with_target("stuff")) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::ERROR).with_target("stuff")) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) + .event(event::expect().at_level(Level::WARN).with_target("stuff")) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -127,9 +127,9 @@ fn add_directive_enables_event() { filter = filter.add_directive("hello=trace".parse().expect("directive should parse")); let (subscriber, finished) = collector::mock() - .event(event::mock().at_level(Level::INFO).with_target("hello")) - .event(event::mock().at_level(Level::TRACE).with_target("hello")) - .done() + .event(event::expect().at_level(Level::INFO).with_target("hello")) + .event(event::expect().at_level(Level::TRACE).with_target("hello")) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -147,19 +147,19 @@ fn span_name_filter_is_dynamic() { .parse() .expect("filter should parse"); let (subscriber, finished) = collector::mock() - .event(event::mock().at_level(Level::INFO)) - .enter(span::mock().named("cool_span")) - .event(event::mock().at_level(Level::DEBUG)) - .enter(span::mock().named("uncool_span")) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::DEBUG)) - .exit(span::mock().named("uncool_span")) - .exit(span::mock().named("cool_span")) - .enter(span::mock().named("uncool_span")) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .exit(span::mock().named("uncool_span")) - .done() + .event(event::expect().at_level(Level::INFO)) + .enter(span::expect().named("cool_span")) + .event(event::expect().at_level(Level::DEBUG)) + .enter(span::expect().named("uncool_span")) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::DEBUG)) + .exit(span::expect().named("uncool_span")) + .exit(span::expect().named("cool_span")) + .enter(span::expect().named("uncool_span")) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .exit(span::expect().named("uncool_span")) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); diff --git a/tracing-subscriber/tests/env_filter/per_subscriber.rs b/tracing-subscriber/tests/env_filter/per_subscriber.rs index 6110dd632c..6020195e89 100644 --- a/tracing-subscriber/tests/env_filter/per_subscriber.rs +++ b/tracing-subscriber/tests/env_filter/per_subscriber.rs @@ -8,10 +8,10 @@ use tracing_mock::{event, field, span, subscriber}; fn level_filter_event() { let filter: EnvFilter = "info".parse().expect("filter should parse"); let (subscriber, handle) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let _collect = tracing_subscriber::registry() @@ -34,18 +34,18 @@ fn same_name_spans() { .expect("filter should parse"); let (subscriber, handle) = subscriber::mock() .new_span( - span::mock() + span::expect() .named("foo") .at_level(Level::TRACE) - .with_field(field::mock("bar")), + .with_field(field::expect("bar")), ) .new_span( - span::mock() + span::expect() .named("foo") .at_level(Level::TRACE) - .with_field(field::mock("baz")), + .with_field(field::expect("baz")), ) - .done() + .only() .run_with_handle(); let _collect = tracing_subscriber::registry() @@ -62,12 +62,12 @@ fn same_name_spans() { fn level_filter_event_with_target() { let filter: EnvFilter = "info,stuff=debug".parse().expect("filter should parse"); let (subscriber, handle) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG).with_target("stuff")) - .event(event::mock().at_level(Level::WARN).with_target("stuff")) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::ERROR).with_target("stuff")) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) + .event(event::expect().at_level(Level::WARN).with_target("stuff")) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .only() .run_with_handle(); let _collect = tracing_subscriber::registry() @@ -96,12 +96,12 @@ fn level_filter_event_with_target_and_span() { let (subscriber, handle) = subscriber::mock() .enter(cool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) .exit(cool_span) - .done() + .only() .run_with_handle(); let _collect = tracing_subscriber::registry() @@ -129,12 +129,12 @@ fn not_order_dependent() { let filter: EnvFilter = "stuff=debug,info".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG).with_target("stuff")) - .event(event::mock().at_level(Level::WARN).with_target("stuff")) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::ERROR).with_target("stuff")) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) + .event(event::expect().at_level(Level::WARN).with_target("stuff")) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .only() .run_with_handle(); let _collect = tracing_subscriber::registry() @@ -164,9 +164,9 @@ fn add_directive_enables_event() { filter = filter.add_directive("hello=trace".parse().expect("directive should parse")); let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::INFO).with_target("hello")) - .event(event::mock().at_level(Level::TRACE).with_target("hello")) - .done() + .event(event::expect().at_level(Level::INFO).with_target("hello")) + .event(event::expect().at_level(Level::TRACE).with_target("hello")) + .only() .run_with_handle(); let _collect = tracing_subscriber::registry() @@ -187,21 +187,21 @@ fn span_name_filter_is_dynamic() { let cool_span = span::named("cool_span"); let uncool_span = span::named("uncool_span"); let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) + .event(event::expect().at_level(Level::INFO)) .enter(cool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) .enter(uncool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::WARN) .in_scope(vec![uncool_span.clone()]), ) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![uncool_span.clone()]), ) @@ -209,17 +209,17 @@ fn span_name_filter_is_dynamic() { .exit(cool_span) .enter(uncool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::WARN) .in_scope(vec![uncool_span.clone()]), ) .event( - event::mock() + event::expect() .at_level(Level::ERROR) .in_scope(vec![uncool_span.clone()]), ) .exit(uncool_span) - .done() + .only() .run_with_handle(); let _collect = tracing_subscriber::registry() @@ -260,12 +260,12 @@ fn multiple_dynamic_filters() { let (subscriber, handle) = subscriber::named("subscriber1") .enter(span.clone()) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![span.clone()]), ) .exit(span) - .done() + .only() .run_with_handle(); (subscriber.with_filter(filter), handle) }; @@ -276,12 +276,12 @@ fn multiple_dynamic_filters() { let (subscriber, handle) = subscriber::named("subscriber2") .enter(span.clone()) .event( - event::mock() + event::expect() .at_level(Level::INFO) .in_scope(vec![span.clone()]), ) .exit(span) - .done() + .only() .run_with_handle(); (subscriber.with_filter(filter), handle) }; diff --git a/tracing-subscriber/tests/field_filter.rs b/tracing-subscriber/tests/field_filter.rs index 1a38b79b67..aad7303aa9 100644 --- a/tracing-subscriber/tests/field_filter.rs +++ b/tracing-subscriber/tests/field_filter.rs @@ -10,16 +10,16 @@ fn field_filter_events() { let filter: EnvFilter = "[{thing}]=debug".parse().expect("filter should parse"); let (subscriber, finished) = collector::mock() .event( - event::mock() + event::expect() .at_level(Level::INFO) - .with_fields(field::mock("thing")), + .with_fields(field::expect("thing")), ) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) - .with_fields(field::mock("thing")), + .with_fields(field::expect("thing")), ) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -41,23 +41,23 @@ fn field_filter_spans() { .parse() .expect("filter should parse"); let (subscriber, finished) = collector::mock() - .enter(span::mock().named("span1")) + .enter(span::expect().named("span1")) .event( - event::mock() + event::expect() .at_level(Level::INFO) - .with_fields(field::mock("something")), + .with_fields(field::expect("something")), ) - .exit(span::mock().named("span1")) - .enter(span::mock().named("span2")) - .exit(span::mock().named("span2")) - .enter(span::mock().named("span3")) + .exit(span::expect().named("span1")) + .enter(span::expect().named("span2")) + .exit(span::expect().named("span2")) + .enter(span::expect().named("span3")) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) - .with_fields(field::mock("something")), + .with_fields(field::expect("something")), ) - .exit(span::mock().named("span3")) - .done() + .exit(span::expect().named("span3")) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -84,16 +84,16 @@ fn record_after_created() { .parse() .expect("filter should parse"); let (subscriber, finished) = collector::mock() - .enter(span::mock().named("span")) - .exit(span::mock().named("span")) + .enter(span::expect().named("span")) + .exit(span::expect().named("span")) .record( - span::mock().named("span"), - field::mock("enabled").with_value(&true), + span::expect().named("span"), + field::expect("enabled").with_value(&true), ) - .enter(span::mock().named("span")) - .event(event::mock().at_level(Level::DEBUG)) - .exit(span::mock().named("span")) - .done() + .enter(span::expect().named("span")) + .event(event::expect().at_level(Level::DEBUG)) + .exit(span::expect().named("span")) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); diff --git a/tracing-subscriber/tests/filter_log.rs b/tracing-subscriber/tests/filter_log.rs index 1a81c9c394..e40c55c71b 100644 --- a/tracing-subscriber/tests/filter_log.rs +++ b/tracing-subscriber/tests/filter_log.rs @@ -36,10 +36,10 @@ fn log_is_enabled() { .parse() .expect("filter should parse"); let (collector, finished) = collector::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); // Note: we have to set the global default in order to set the `log` max diff --git a/tracing-subscriber/tests/hinted_subscriber_filters_dont_break_other_subscribers.rs b/tracing-subscriber/tests/hinted_subscriber_filters_dont_break_other_subscribers.rs index 3a0b9e30d2..7365717bd3 100644 --- a/tracing-subscriber/tests/hinted_subscriber_filters_dont_break_other_subscribers.rs +++ b/tracing-subscriber/tests/hinted_subscriber_filters_dont_break_other_subscribers.rs @@ -2,7 +2,7 @@ use tracing::{Collect, Level, Metadata}; use tracing_mock::{ collector, event, - subscriber::{self, ExpectSubscriber}, + subscriber::{self, MockSubscriber}, }; use tracing_subscriber::{filter::DynFilterFn, prelude::*, subscribe::Context}; @@ -112,22 +112,22 @@ fn filter() -> DynFilterFn { .with_max_level_hint(Level::INFO) } -fn unfiltered(name: &str) -> (ExpectSubscriber, collector::MockHandle) { +fn unfiltered(name: &str) -> (MockSubscriber, collector::MockHandle) { subscriber::named(name) - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } -fn filtered(name: &str) -> (ExpectSubscriber, collector::MockHandle) { +fn filtered(name: &str) -> (MockSubscriber, collector::MockHandle) { subscriber::named(name) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } diff --git a/tracing-subscriber/tests/multiple_subscriber_filter_interests_cached.rs b/tracing-subscriber/tests/multiple_subscriber_filter_interests_cached.rs index b7660176e9..c8a647d5bb 100644 --- a/tracing-subscriber/tests/multiple_subscriber_filter_interests_cached.rs +++ b/tracing-subscriber/tests/multiple_subscriber_filter_interests_cached.rs @@ -23,13 +23,13 @@ fn multiple_subscriber_filter_interests_are_cached() { let seen_info = seen_info2; let (info_subscriber, info_handle) = subscriber::named("info") - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let info_subscriber = info_subscriber.with_filter(filter); @@ -47,11 +47,11 @@ fn multiple_subscriber_filter_interests_are_cached() { let seen_warn = seen_warn2; let (warn_subscriber, warn_handle) = subscriber::named("warn") - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let warn_subscriber = warn_subscriber.with_filter(filter); diff --git a/tracing-subscriber/tests/reload_max_log_level.rs b/tracing-subscriber/tests/reload_max_log_level.rs index ec172d5b8d..6c606302ea 100644 --- a/tracing-subscriber/tests/reload_max_log_level.rs +++ b/tracing-subscriber/tests/reload_max_log_level.rs @@ -7,10 +7,10 @@ use tracing_subscriber::{filter::LevelFilter, prelude::*, reload}; #[test] fn reload_max_log_level() { let (collector, finished) = collector::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let (filter, reload_handle) = reload::Subscriber::new(LevelFilter::INFO); collector.with(filter).init(); diff --git a/tracing-subscriber/tests/same_len_filters.rs b/tracing-subscriber/tests/same_len_filters.rs index 523e9819a2..a35c2aefeb 100644 --- a/tracing-subscriber/tests/same_len_filters.rs +++ b/tracing-subscriber/tests/same_len_filters.rs @@ -10,9 +10,9 @@ use tracing_subscriber::{filter::EnvFilter, prelude::*}; fn same_length_targets() { let filter: EnvFilter = "foo=trace,bar=trace".parse().expect("filter should parse"); let (subscriber, finished) = collector::mock() - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::TRACE)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::TRACE)) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -31,16 +31,16 @@ fn same_num_fields_event() { .expect("filter should parse"); let (subscriber, finished) = collector::mock() .event( - event::mock() + event::expect() .at_level(Level::TRACE) - .with_fields(field::mock("foo")), + .with_fields(field::expect("foo")), ) .event( - event::mock() + event::expect() .at_level(Level::TRACE) - .with_fields(field::mock("bar")), + .with_fields(field::expect("bar")), ) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); with_default(subscriber, || { @@ -58,18 +58,18 @@ fn same_num_fields_and_name_len() { .expect("filter should parse"); let (subscriber, finished) = collector::mock() .new_span( - span::mock() + span::expect() .named("foo") .at_level(Level::TRACE) - .with_field(field::mock("bar")), + .with_field(field::expect("bar")), ) .new_span( - span::mock() + span::expect() .named("baz") .at_level(Level::TRACE) - .with_field(field::mock("boz")), + .with_field(field::expect("boz")), ) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); with_default(subscriber, || { diff --git a/tracing-subscriber/tests/subscriber_filter_interests_are_cached.rs b/tracing-subscriber/tests/subscriber_filter_interests_are_cached.rs index 88ea93d5c5..70f7642c43 100644 --- a/tracing-subscriber/tests/subscriber_filter_interests_are_cached.rs +++ b/tracing-subscriber/tests/subscriber_filter_interests_are_cached.rs @@ -21,9 +21,9 @@ fn subscriber_filter_interests_are_cached() { }); let (expect, handle) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let subscriber = tracing_subscriber::registry().with(expect.with_filter(filter)); diff --git a/tracing-subscriber/tests/subscriber_filters/boxed.rs b/tracing-subscriber/tests/subscriber_filters/boxed.rs index 85c9992a1a..288de4cf71 100644 --- a/tracing-subscriber/tests/subscriber_filters/boxed.rs +++ b/tracing-subscriber/tests/subscriber_filters/boxed.rs @@ -2,7 +2,7 @@ use super::*; use tracing_subscriber::{filter, prelude::*, Subscribe}; fn subscribe() -> (ExpectSubscriber, subscriber::MockHandle) { - subscribe::mock().done().run_with_handle() + subscribe::mock().only().run_with_handle() } fn filter() -> filter::DynFilterFn { diff --git a/tracing-subscriber/tests/subscriber_filters/combinators.rs b/tracing-subscriber/tests/subscriber_filters/combinators.rs index 7cc84d8465..50c6bfbc7d 100644 --- a/tracing-subscriber/tests/subscriber_filters/combinators.rs +++ b/tracing-subscriber/tests/subscriber_filters/combinators.rs @@ -12,7 +12,7 @@ fn and() { .at_level(tracing::Level::INFO) .with_target("interesting_target"), ) - .done() + .only() .run_with_handle(); // Enables spans and events with targets starting with `interesting_target`: diff --git a/tracing-subscriber/tests/subscriber_filters/filter_scopes.rs b/tracing-subscriber/tests/subscriber_filters/filter_scopes.rs index 0de398b2e8..bddf570c12 100644 --- a/tracing-subscriber/tests/subscriber_filters/filter_scopes.rs +++ b/tracing-subscriber/tests/subscriber_filters/filter_scopes.rs @@ -1,49 +1,49 @@ use super::*; -use tracing_mock::subscriber::ExpectSubscriber; +use tracing_mock::subscriber::MockSubscriber; #[test] fn filters_span_scopes() { let (debug_subscriber, debug_handle) = subscriber::named("debug") - .enter(span::mock().at_level(Level::DEBUG)) - .enter(span::mock().at_level(Level::INFO)) - .enter(span::mock().at_level(Level::WARN)) - .enter(span::mock().at_level(Level::ERROR)) + .enter(span::expect().at_level(Level::DEBUG)) + .enter(span::expect().at_level(Level::INFO)) + .enter(span::expect().at_level(Level::WARN)) + .enter(span::expect().at_level(Level::ERROR)) .event(event::msg("hello world").in_scope(vec![ - span::mock().at_level(Level::ERROR), - span::mock().at_level(Level::WARN), - span::mock().at_level(Level::INFO), - span::mock().at_level(Level::DEBUG), + span::expect().at_level(Level::ERROR), + span::expect().at_level(Level::WARN), + span::expect().at_level(Level::INFO), + span::expect().at_level(Level::DEBUG), ])) - .exit(span::mock().at_level(Level::ERROR)) - .exit(span::mock().at_level(Level::WARN)) - .exit(span::mock().at_level(Level::INFO)) - .exit(span::mock().at_level(Level::DEBUG)) - .done() + .exit(span::expect().at_level(Level::ERROR)) + .exit(span::expect().at_level(Level::WARN)) + .exit(span::expect().at_level(Level::INFO)) + .exit(span::expect().at_level(Level::DEBUG)) + .only() .run_with_handle(); let (info_subscriber, info_handle) = subscriber::named("info") - .enter(span::mock().at_level(Level::INFO)) - .enter(span::mock().at_level(Level::WARN)) - .enter(span::mock().at_level(Level::ERROR)) + .enter(span::expect().at_level(Level::INFO)) + .enter(span::expect().at_level(Level::WARN)) + .enter(span::expect().at_level(Level::ERROR)) .event(event::msg("hello world").in_scope(vec![ - span::mock().at_level(Level::ERROR), - span::mock().at_level(Level::WARN), - span::mock().at_level(Level::INFO), + span::expect().at_level(Level::ERROR), + span::expect().at_level(Level::WARN), + span::expect().at_level(Level::INFO), ])) - .exit(span::mock().at_level(Level::ERROR)) - .exit(span::mock().at_level(Level::WARN)) - .exit(span::mock().at_level(Level::INFO)) - .done() + .exit(span::expect().at_level(Level::ERROR)) + .exit(span::expect().at_level(Level::WARN)) + .exit(span::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let (warn_subscriber, warn_handle) = subscriber::named("warn") - .enter(span::mock().at_level(Level::WARN)) - .enter(span::mock().at_level(Level::ERROR)) + .enter(span::expect().at_level(Level::WARN)) + .enter(span::expect().at_level(Level::ERROR)) .event(event::msg("hello world").in_scope(vec![ - span::mock().at_level(Level::ERROR), - span::mock().at_level(Level::WARN), + span::expect().at_level(Level::ERROR), + span::expect().at_level(Level::WARN), ])) - .exit(span::mock().at_level(Level::ERROR)) - .exit(span::mock().at_level(Level::WARN)) - .done() + .exit(span::expect().at_level(Level::ERROR)) + .exit(span::expect().at_level(Level::WARN)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -68,40 +68,40 @@ fn filters_span_scopes() { #[test] fn filters_interleaved_span_scopes() { - fn target_subscriber(target: &'static str) -> (ExpectSubscriber, collector::MockHandle) { + fn target_subscriber(target: &'static str) -> (MockSubscriber, collector::MockHandle) { subscriber::named(format!("target_{}", target)) - .enter(span::mock().with_target(target)) - .enter(span::mock().with_target(target)) + .enter(span::expect().with_target(target)) + .enter(span::expect().with_target(target)) .event(event::msg("hello world").in_scope(vec![ - span::mock().with_target(target), - span::mock().with_target(target), + span::expect().with_target(target), + span::expect().with_target(target), ])) .event( event::msg("hello to my target") .in_scope(vec![ - span::mock().with_target(target), - span::mock().with_target(target), + span::expect().with_target(target), + span::expect().with_target(target), ]) .with_target(target), ) - .exit(span::mock().with_target(target)) - .exit(span::mock().with_target(target)) - .done() + .exit(span::expect().with_target(target)) + .exit(span::expect().with_target(target)) + .only() .run_with_handle() } let (a_subscriber, a_handle) = target_subscriber("a"); let (b_subscriber, b_handle) = target_subscriber("b"); let (all_subscriber, all_handle) = subscriber::named("all") - .enter(span::mock().with_target("b")) - .enter(span::mock().with_target("a")) + .enter(span::expect().with_target("b")) + .enter(span::expect().with_target("a")) .event(event::msg("hello world").in_scope(vec![ - span::mock().with_target("a"), - span::mock().with_target("b"), + span::expect().with_target("a"), + span::expect().with_target("b"), ])) - .exit(span::mock().with_target("a")) - .exit(span::mock().with_target("b")) - .done() + .exit(span::expect().with_target("a")) + .exit(span::expect().with_target("b")) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() diff --git a/tracing-subscriber/tests/subscriber_filters/main.rs b/tracing-subscriber/tests/subscriber_filters/main.rs index 897175cfc8..12db2b0f41 100644 --- a/tracing-subscriber/tests/subscriber_filters/main.rs +++ b/tracing-subscriber/tests/subscriber_filters/main.rs @@ -12,21 +12,21 @@ use tracing_subscriber::{filter, prelude::*, Subscribe}; #[test] fn basic_subscriber_filters() { let (trace_subscriber, trace_handle) = subscriber::named("trace") - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let (debug_subscriber, debug_handle) = subscriber::named("debug") - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let (info_subscriber, info_handle) = subscriber::named("info") - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -47,21 +47,21 @@ fn basic_subscriber_filters() { #[test] fn basic_subscriber_filters_spans() { let (trace_subscriber, trace_handle) = subscriber::named("trace") - .new_span(span::mock().at_level(Level::TRACE)) - .new_span(span::mock().at_level(Level::DEBUG)) - .new_span(span::mock().at_level(Level::INFO)) - .done() + .new_span(span::expect().at_level(Level::TRACE)) + .new_span(span::expect().at_level(Level::DEBUG)) + .new_span(span::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let (debug_subscriber, debug_handle) = subscriber::named("debug") - .new_span(span::mock().at_level(Level::DEBUG)) - .new_span(span::mock().at_level(Level::INFO)) - .done() + .new_span(span::expect().at_level(Level::DEBUG)) + .new_span(span::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let (info_subscriber, info_handle) = subscriber::named("info") - .new_span(span::mock().at_level(Level::INFO)) - .done() + .new_span(span::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -82,10 +82,10 @@ fn basic_subscriber_filters_spans() { #[test] fn global_filters_subscribers_still_work() { let (expect, handle) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -105,9 +105,9 @@ fn global_filters_subscribers_still_work() { #[test] fn global_filter_interests_are_cached() { let (expect, handle) = subscriber::mock() - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -133,10 +133,10 @@ fn global_filter_interests_are_cached() { #[test] fn global_filters_affect_subscriber_filters() { let (expect, handle) = subscriber::named("debug") - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -158,17 +158,17 @@ fn filter_fn() { let (all, all_handle) = subscriber::named("all_targets") .event(event::msg("hello foo")) .event(event::msg("hello bar")) - .done() + .only() .run_with_handle(); let (foo, foo_handle) = subscriber::named("foo_target") .event(event::msg("hello foo")) - .done() + .only() .run_with_handle(); let (bar, bar_handle) = subscriber::named("bar_target") .event(event::msg("hello bar")) - .done() + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() diff --git a/tracing-subscriber/tests/subscriber_filters/per_event.rs b/tracing-subscriber/tests/subscriber_filters/per_event.rs index f4d3febc09..1c7f5e3fbf 100644 --- a/tracing-subscriber/tests/subscriber_filters/per_event.rs +++ b/tracing-subscriber/tests/subscriber_filters/per_event.rs @@ -42,9 +42,9 @@ impl Filter for FilterEvent { #[test] fn per_subscriber_event_field_filtering() { let (expect, handle) = subscriber::mock() - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() diff --git a/tracing-subscriber/tests/subscriber_filters/targets.rs b/tracing-subscriber/tests/subscriber_filters/targets.rs index f96e9feb0d..4e3a504764 100644 --- a/tracing-subscriber/tests/subscriber_filters/targets.rs +++ b/tracing-subscriber/tests/subscriber_filters/targets.rs @@ -39,7 +39,7 @@ fn inner_subscriber_short_circuits() { let (subscriber, handle) = subscriber::mock() .event(event::msg("hello world")) - .done() + .only() .run_with_handle(); let filter = Targets::new().with_target("magic_target", LevelFilter::DEBUG); diff --git a/tracing-subscriber/tests/subscriber_filters/trees.rs b/tracing-subscriber/tests/subscriber_filters/trees.rs index 3227e69a5e..a2166bd739 100644 --- a/tracing-subscriber/tests/subscriber_filters/trees.rs +++ b/tracing-subscriber/tests/subscriber_filters/trees.rs @@ -1,37 +1,49 @@ use super::*; -use tracing_mock::subscriber::ExpectSubscriber; +use tracing_mock::subscriber::MockSubscriber; #[test] fn basic_trees() { let (with_target, with_target_handle) = subscriber::named("info_with_target") - .event(event::mock().at_level(Level::INFO).with_target("my_target")) - .done() + .event( + event::expect() + .at_level(Level::INFO) + .with_target("my_target"), + ) + .only() .run_with_handle(); let (info, info_handle) = subscriber::named("info") .event( - event::mock() + event::expect() .at_level(Level::INFO) .with_target(module_path!()), ) - .event(event::mock().at_level(Level::INFO).with_target("my_target")) - .done() + .event( + event::expect() + .at_level(Level::INFO) + .with_target("my_target"), + ) + .only() .run_with_handle(); let (all, all_handle) = subscriber::named("all") .event( - event::mock() + event::expect() .at_level(Level::INFO) .with_target(module_path!()), ) - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::INFO).with_target("my_target")) + .event(event::expect().at_level(Level::TRACE)) + .event( + event::expect() + .at_level(Level::INFO) + .with_target("my_target"), + ) .event( - event::mock() + event::expect() .at_level(Level::TRACE) .with_target("my_target"), ) - .done() + .only() .run_with_handle(); let info_tree = info @@ -55,43 +67,42 @@ fn basic_trees() { #[test] fn filter_span_scopes() { - fn target_subscriber(target: &'static str) -> (ExpectSubscriber, collector::MockHandle) { + fn target_subscriber(target: &'static str) -> (MockSubscriber, collector::MockHandle) { subscriber::named(format!("target_{}", target)) - .enter(span::mock().with_target(target).at_level(Level::INFO)) - .event( - event::msg("hello world") - .in_scope(vec![span::mock().with_target(target).at_level(Level::INFO)]), - ) - .exit(span::mock().with_target(target).at_level(Level::INFO)) - .done() + .enter(span::expect().with_target(target).at_level(Level::INFO)) + .event(event::msg("hello world").in_scope(vec![ + span::expect().with_target(target).at_level(Level::INFO), + ])) + .exit(span::expect().with_target(target).at_level(Level::INFO)) + .only() .run_with_handle() } let (a_subscriber, a_handle) = target_subscriber("a"); let (b_subscriber, b_handle) = target_subscriber("b"); let (info_subscriber, info_handle) = subscriber::named("info") - .enter(span::mock().with_target("b").at_level(Level::INFO)) - .enter(span::mock().with_target("a").at_level(Level::INFO)) + .enter(span::expect().with_target("b").at_level(Level::INFO)) + .enter(span::expect().with_target("a").at_level(Level::INFO)) .event(event::msg("hello world").in_scope(vec![ - span::mock().with_target("a").at_level(Level::INFO), - span::mock().with_target("b").at_level(Level::INFO), + span::expect().with_target("a").at_level(Level::INFO), + span::expect().with_target("b").at_level(Level::INFO), ])) - .exit(span::mock().with_target("a").at_level(Level::INFO)) - .exit(span::mock().with_target("b").at_level(Level::INFO)) - .done() + .exit(span::expect().with_target("a").at_level(Level::INFO)) + .exit(span::expect().with_target("b").at_level(Level::INFO)) + .only() .run_with_handle(); let full_scope = vec![ - span::mock().with_target("b").at_level(Level::TRACE), - span::mock().with_target("a").at_level(Level::INFO), - span::mock().with_target("b").at_level(Level::INFO), - span::mock().with_target("a").at_level(Level::TRACE), + span::expect().with_target("b").at_level(Level::TRACE), + span::expect().with_target("a").at_level(Level::INFO), + span::expect().with_target("b").at_level(Level::INFO), + span::expect().with_target("a").at_level(Level::TRACE), ]; let (all_subscriber, all_handle) = subscriber::named("all") - .enter(span::mock().with_target("a").at_level(Level::TRACE)) - .enter(span::mock().with_target("b").at_level(Level::INFO)) - .enter(span::mock().with_target("a").at_level(Level::INFO)) - .enter(span::mock().with_target("b").at_level(Level::TRACE)) + .enter(span::expect().with_target("a").at_level(Level::TRACE)) + .enter(span::expect().with_target("b").at_level(Level::INFO)) + .enter(span::expect().with_target("a").at_level(Level::INFO)) + .enter(span::expect().with_target("b").at_level(Level::TRACE)) .event(event::msg("hello world").in_scope(full_scope.clone())) .event( event::msg("hello to my target") @@ -103,11 +114,11 @@ fn filter_span_scopes() { .with_target("b") .in_scope(full_scope), ) - .exit(span::mock().with_target("b").at_level(Level::TRACE)) - .exit(span::mock().with_target("a").at_level(Level::INFO)) - .exit(span::mock().with_target("b").at_level(Level::INFO)) - .exit(span::mock().with_target("a").at_level(Level::TRACE)) - .done() + .exit(span::expect().with_target("b").at_level(Level::TRACE)) + .exit(span::expect().with_target("a").at_level(Level::INFO)) + .exit(span::expect().with_target("b").at_level(Level::INFO)) + .exit(span::expect().with_target("a").at_level(Level::TRACE)) + .only() .run_with_handle(); let a_subscriber = a_subscriber.with_filter(filter::filter_fn(|meta| { diff --git a/tracing-subscriber/tests/subscriber_filters/vec.rs b/tracing-subscriber/tests/subscriber_filters/vec.rs index b10ecf8ab9..1ea5b6b957 100644 --- a/tracing-subscriber/tests/subscriber_filters/vec.rs +++ b/tracing-subscriber/tests/subscriber_filters/vec.rs @@ -1,27 +1,27 @@ use super::*; use tracing::Collect; -use tracing_mock::subscriber::ExpectSubscriber; +use tracing_mock::subscriber::MockSubscriber; #[test] fn with_filters_unboxed() { let (trace_subscriber, trace_handle) = subscriber::named("trace") - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let trace_subscriber = trace_subscriber.with_filter(LevelFilter::TRACE); let (debug_subscriber, debug_handle) = subscriber::named("debug") - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let debug_subscriber = debug_subscriber.with_filter(LevelFilter::DEBUG); let (info_subscriber, info_handle) = subscriber::named("info") - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let info_subscriber = info_subscriber.with_filter(LevelFilter::INFO); @@ -41,23 +41,23 @@ fn with_filters_unboxed() { #[test] fn with_filters_boxed() { let (unfiltered_subscriber, unfiltered_handle) = subscriber::named("unfiltered") - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let unfiltered_subscriber = unfiltered_subscriber.boxed(); let (debug_subscriber, debug_handle) = subscriber::named("debug") - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let debug_subscriber = debug_subscriber.with_filter(LevelFilter::DEBUG).boxed(); let (target_subscriber, target_handle) = subscriber::named("target") - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let target_subscriber = target_subscriber .with_filter(filter::filter_fn(|meta| meta.target() == "my_target")) @@ -120,6 +120,6 @@ fn all_filtered_max_level_hint() { #[test] fn empty_vec() { // Just a None means everything is off - let collector = tracing_subscriber::registry().with(Vec::::new()); + let collector = tracing_subscriber::registry().with(Vec::::new()); assert_eq!(collector.max_level_hint(), Some(LevelFilter::OFF)); } diff --git a/tracing-subscriber/tests/unhinted_subscriber_filters_dont_break_other_subscribers.rs b/tracing-subscriber/tests/unhinted_subscriber_filters_dont_break_other_subscribers.rs index 87fc803e65..efe41acb7a 100644 --- a/tracing-subscriber/tests/unhinted_subscriber_filters_dont_break_other_subscribers.rs +++ b/tracing-subscriber/tests/unhinted_subscriber_filters_dont_break_other_subscribers.rs @@ -2,7 +2,7 @@ use tracing::Level; use tracing_mock::{ collector, event, - subscriber::{self, ExpectSubscriber}, + subscriber::{self, MockSubscriber}, }; use tracing_subscriber::{filter::DynFilterFn, prelude::*}; @@ -104,22 +104,22 @@ fn filter() -> DynFilterFn { DynFilterFn::new(|metadata, _| metadata.level() <= &Level::INFO) } -fn unfiltered(name: &str) -> (ExpectSubscriber, collector::MockHandle) { +fn unfiltered(name: &str) -> (MockSubscriber, collector::MockHandle) { subscriber::named(name) - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } -fn filtered(name: &str) -> (ExpectSubscriber, collector::MockHandle) { +fn filtered(name: &str) -> (MockSubscriber, collector::MockHandle) { subscriber::named(name) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } diff --git a/tracing-subscriber/tests/utils.rs b/tracing-subscriber/tests/utils.rs index 34e9bb6eae..2d122f8815 100644 --- a/tracing-subscriber/tests/utils.rs +++ b/tracing-subscriber/tests/utils.rs @@ -7,11 +7,11 @@ use tracing_subscriber::prelude::*; fn init_ext_works() { let (subscriber, finished) = collector::mock() .event( - event::mock() + event::expect() .at_level(tracing::Level::INFO) .with_target("init_works"), ) - .done() + .only() .run_with_handle(); let _guard = subscriber.set_default(); diff --git a/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs b/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs index 6e6b01e75e..303b1c0284 100644 --- a/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs +++ b/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs @@ -6,13 +6,13 @@ use std::{ use tracing::{Collect, Level}; use tracing_mock::{ event, - subscriber::{self, ExpectSubscriber}, + subscriber::{self, MockSubscriber}, }; use tracing_subscriber::{filter, prelude::*}; #[test] fn vec_subscriber_filter_interests_are_cached() { - let mk_filtered = |level: Level, subscriber: ExpectSubscriber| { + let mk_filtered = |level: Level, subscriber: MockSubscriber| { let seen = Arc::new(Mutex::new(HashMap::new())); let filter = filter::filter_fn({ let seen = seen.clone(); @@ -26,23 +26,23 @@ fn vec_subscriber_filter_interests_are_cached() { // This subscriber will return Interest::always for INFO and lower. let (info_subscriber, info_handle) = subscriber::named("info") - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let (info_subscriber, seen_info) = mk_filtered(Level::INFO, info_subscriber); // This subscriber will return Interest::always for WARN and lower. let (warn_subscriber, warn_handle) = subscriber::named("warn") - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let (warn_subscriber, seen_warn) = mk_filtered(Level::WARN, warn_subscriber); diff --git a/tracing/tests/collector.rs b/tracing/tests/collector.rs index fa602ac4bf..8518230253 100644 --- a/tracing/tests/collector.rs +++ b/tracing/tests/collector.rs @@ -65,16 +65,16 @@ fn event_macros_dont_infinite_loop() { fn boxed_collector() { let (collector, handle) = collector::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("bar") + span::expect().named("foo").with_field( + field::expect("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); let collector: Box = Box::new(collector); @@ -98,20 +98,20 @@ fn arced_collector() { let (collector, handle) = collector::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("bar") + span::expect().named("foo").with_field( + field::expect("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .event( - event::mock() - .with_fields(field::mock("message").with_value(&display("hello from my event"))), + event::expect() + .with_fields(field::expect("message").with_value(&display("hello from my event"))), ) - .done() + .only() .run_with_handle(); let collector: Arc = Arc::new(collector); diff --git a/tracing/tests/enabled.rs b/tracing/tests/enabled.rs index 2b77f19e07..9c82309056 100644 --- a/tracing/tests/enabled.rs +++ b/tracing/tests/enabled.rs @@ -16,7 +16,7 @@ fn level_and_target() { meta.level() <= &Level::INFO } }) - .done() + .only() .run(); let _guard = tracing::collect::set_default(collector); @@ -41,7 +41,7 @@ fn span_and_event() { meta.level() <= &Level::INFO } }) - .done() + .only() .run(); let _guard = tracing::collect::set_default(collector); diff --git a/tracing/tests/event.rs b/tracing/tests/event.rs index 7f0d7eae16..855a340fb2 100644 --- a/tracing/tests/event.rs +++ b/tracing/tests/event.rs @@ -21,17 +21,17 @@ macro_rules! event_without_message { fn $name() { let (collector, handle) = collector::mock() .event( - event::mock().with_fields( - field::mock("answer") + event::expect().with_fields( + field::expect("answer") .with_value(&42) .and( - field::mock("to_question") + field::expect("to_question") .with_value(&"life, the universe, and everything"), ) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -56,13 +56,15 @@ event_without_message! {nonzeroi32_event_without_message: std::num::NonZeroI32:: #[test] fn event_with_message() { let (collector, handle) = collector::mock() - .event(event::mock().with_fields(field::mock("message").with_value( - &tracing::field::debug(format_args!( - "hello from my tracing::event! yak shaved = {:?}", - true + .event( + event::expect().with_fields(field::expect("message").with_value( + &tracing::field::debug(format_args!( + "hello from my tracing::event! yak shaved = {:?}", + true + )), )), - ))) - .done() + ) + .only() .run_with_handle(); with_default(collector, || { @@ -77,10 +79,12 @@ fn event_with_message() { fn message_without_delims() { let (collector, handle) = collector::mock() .event( - event::mock().with_fields( - field::mock("answer") + event::expect().with_fields( + field::expect("answer") .with_value(&42) - .and(field::mock("question").with_value(&"life, the universe, and everything")) + .and( + field::expect("question").with_value(&"life, the universe, and everything"), + ) .and(field::msg(format_args!( "hello from my event! tricky? {:?}!", true @@ -88,7 +92,7 @@ fn message_without_delims() { .only(), ), ) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -104,15 +108,17 @@ fn message_without_delims() { fn string_message_without_delims() { let (collector, handle) = collector::mock() .event( - event::mock().with_fields( - field::mock("answer") + event::expect().with_fields( + field::expect("answer") .with_value(&42) - .and(field::mock("question").with_value(&"life, the universe, and everything")) + .and( + field::expect("question").with_value(&"life, the universe, and everything"), + ) .and(field::msg(format_args!("hello from my event"))) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -128,23 +134,23 @@ fn string_message_without_delims() { fn one_with_everything() { let (collector, handle) = collector::mock() .event( - event::mock() + event::expect() .with_fields( - field::mock("message") + field::expect("message") .with_value(&tracing::field::debug(format_args!( "{:#x} make me one with{what:.>20}", 4_277_009_102u64, what = "everything" ))) - .and(field::mock("foo").with_value(&666)) - .and(field::mock("bar").with_value(&false)) - .and(field::mock("like_a_butterfly").with_value(&42.0)) + .and(field::expect("foo").with_value(&666)) + .and(field::expect("bar").with_value(&false)) + .and(field::expect("like_a_butterfly").with_value(&42.0)) .only(), ) .at_level(Level::ERROR) .with_target("whatever"), ) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -164,13 +170,13 @@ fn one_with_everything() { fn moved_field() { let (collector, handle) = collector::mock() .event( - event::mock().with_fields( - field::mock("foo") + event::expect().with_fields( + field::expect("foo") .with_value(&display("hello from my event")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(collector, || { let from = "my event"; @@ -185,14 +191,14 @@ fn moved_field() { fn dotted_field_name() { let (collector, handle) = collector::mock() .event( - event::mock().with_fields( - field::mock("foo.bar") + event::expect().with_fields( + field::expect("foo.bar") .with_value(&true) - .and(field::mock("foo.baz").with_value(&false)) + .and(field::expect("foo.baz").with_value(&false)) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(collector, || { tracing::event!(Level::INFO, foo.bar = true, foo.baz = false); @@ -206,13 +212,13 @@ fn dotted_field_name() { fn borrowed_field() { let (collector, handle) = collector::mock() .event( - event::mock().with_fields( - field::mock("foo") + event::expect().with_fields( + field::expect("foo") .with_value(&display("hello from my event")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(collector, || { let from = "my event"; @@ -243,15 +249,15 @@ fn move_field_out_of_struct() { }; let (collector, handle) = collector::mock() .event( - event::mock().with_fields( - field::mock("x") + event::expect().with_fields( + field::expect("x") .with_value(&debug(3.234)) - .and(field::mock("y").with_value(&debug(-1.223))) + .and(field::expect("y").with_value(&debug(-1.223))) .only(), ), ) - .event(event::mock().with_fields(field::mock("position").with_value(&debug(&pos)))) - .done() + .event(event::expect().with_fields(field::expect("position").with_value(&debug(&pos)))) + .only() .run_with_handle(); with_default(collector, || { @@ -270,13 +276,13 @@ fn move_field_out_of_struct() { fn display_shorthand() { let (collector, handle) = collector::mock() .event( - event::mock().with_fields( - field::mock("my_field") + event::expect().with_fields( + field::expect("my_field") .with_value(&display("hello world")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(collector, || { tracing::event!(Level::TRACE, my_field = %"hello world"); @@ -290,13 +296,13 @@ fn display_shorthand() { fn debug_shorthand() { let (collector, handle) = collector::mock() .event( - event::mock().with_fields( - field::mock("my_field") + event::expect().with_fields( + field::expect("my_field") .with_value(&debug("hello world")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(collector, || { tracing::event!(Level::TRACE, my_field = ?"hello world"); @@ -310,14 +316,14 @@ fn debug_shorthand() { fn both_shorthands() { let (collector, handle) = collector::mock() .event( - event::mock().with_fields( - field::mock("display_field") + event::expect().with_fields( + field::expect("display_field") .with_value(&display("hello world")) - .and(field::mock("debug_field").with_value(&debug("hello world"))) + .and(field::expect("debug_field").with_value(&debug("hello world"))) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(collector, || { tracing::event!(Level::TRACE, display_field = %"hello world", debug_field = ?"hello world"); @@ -330,9 +336,9 @@ fn both_shorthands() { #[test] fn explicit_child() { let (collector, handle) = collector::mock() - .new_span(span::mock().named("foo")) - .event(event::mock().with_explicit_parent(Some("foo"))) - .done() + .new_span(span::expect().named("foo")) + .event(event::expect().with_explicit_parent(Some("foo"))) + .only() .run_with_handle(); with_default(collector, || { @@ -347,13 +353,13 @@ fn explicit_child() { #[test] fn explicit_child_at_levels() { let (collector, handle) = collector::mock() - .new_span(span::mock().named("foo")) - .event(event::mock().with_explicit_parent(Some("foo"))) - .event(event::mock().with_explicit_parent(Some("foo"))) - .event(event::mock().with_explicit_parent(Some("foo"))) - .event(event::mock().with_explicit_parent(Some("foo"))) - .event(event::mock().with_explicit_parent(Some("foo"))) - .done() + .new_span(span::expect().named("foo")) + .event(event::expect().with_explicit_parent(Some("foo"))) + .event(event::expect().with_explicit_parent(Some("foo"))) + .event(event::expect().with_explicit_parent(Some("foo"))) + .event(event::expect().with_explicit_parent(Some("foo"))) + .event(event::expect().with_explicit_parent(Some("foo"))) + .only() .run_with_handle(); with_default(collector, || { @@ -372,11 +378,15 @@ fn explicit_child_at_levels() { #[test] fn string_field() { let (collector, handle) = collector::mock() - .event(event::mock().with_fields(field::mock("my_string").with_value(&"hello").only())) + .event(event::expect().with_fields(field::expect("my_string").with_value(&"hello").only())) .event( - event::mock().with_fields(field::mock("my_string").with_value(&"hello world!").only()), + event::expect().with_fields( + field::expect("my_string") + .with_value(&"hello world!") + .only(), + ), ) - .done() + .only() .run_with_handle(); with_default(collector, || { let mut my_string = String::from("hello"); diff --git a/tracing/tests/filters_dont_leak.rs b/tracing/tests/filters_dont_leak.rs index 1f4e07801b..7e9553a35e 100644 --- a/tracing/tests/filters_dont_leak.rs +++ b/tracing/tests/filters_dont_leak.rs @@ -13,14 +13,14 @@ fn spans_dont_leak() { let (collector, handle) = collector::mock() .named("spans/subscriber1") .with_filter(|_| false) - .done() + .only() .run_with_handle(); let _guard = tracing::collect::set_default(collector); do_span(); - let alice = span::mock().named("alice"); + let alice = span::expect().named("alice"); let (subscriber2, handle2) = collector::mock() .named("spans/subscriber2") .with_filter(|_| true) @@ -28,7 +28,7 @@ fn spans_dont_leak() { .enter(alice.clone()) .exit(alice.clone()) .drop_span(alice) - .done() + .only() .run_with_handle(); tracing::collect::with_default(subscriber2, || { @@ -53,7 +53,7 @@ fn events_dont_leak() { let (collector, handle) = collector::mock() .named("events/collector1") .with_filter(|_| false) - .done() + .only() .run_with_handle(); let _guard = tracing::collect::set_default(collector); @@ -63,8 +63,8 @@ fn events_dont_leak() { let (collector2, handle2) = collector::mock() .named("events/collector2") .with_filter(|_| true) - .event(event::mock()) - .done() + .event(event::expect()) + .only() .run_with_handle(); tracing::collect::with_default(collector2, || { diff --git a/tracing/tests/max_level_hint.rs b/tracing/tests/max_level_hint.rs index 007bd8bbfa..4f996667b3 100644 --- a/tracing/tests/max_level_hint.rs +++ b/tracing/tests/max_level_hint.rs @@ -24,10 +24,10 @@ fn max_level_hints() { ); true }) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); tracing::collect::set_global_default(collector).unwrap(); diff --git a/tracing/tests/multiple_max_level_hints.rs b/tracing/tests/multiple_max_level_hints.rs index 019f2b7cd4..bdc884de2a 100644 --- a/tracing/tests/multiple_max_level_hints.rs +++ b/tracing/tests/multiple_max_level_hints.rs @@ -35,10 +35,10 @@ fn multiple_max_level_hints() { ); level <= &Level::INFO }) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let (subscriber2, handle2) = collector::mock() .named("subscriber2") @@ -51,11 +51,11 @@ fn multiple_max_level_hints() { ); level <= &Level::DEBUG }) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let dispatch1 = tracing::Dispatch::new(subscriber1); diff --git a/tracing/tests/no_collector.rs b/tracing/tests/no_collector.rs index 4a65b7781d..8283207cac 100644 --- a/tracing/tests/no_collector.rs +++ b/tracing/tests/no_collector.rs @@ -7,7 +7,7 @@ use tracing_mock::*; #[test] fn no_collector_disables_global() { // Reproduces https://github.com/tokio-rs/tracing/issues/1999 - let (collector, handle) = collector::mock().done().run_with_handle(); + let (collector, handle) = collector::mock().only().run_with_handle(); collect::set_global_default(collector).expect("setting global default must succeed"); collect::with_default(collect::NoCollector::default(), || { tracing::info!("this should not be recorded"); diff --git a/tracing/tests/span.rs b/tracing/tests/span.rs index 9af23cfeaa..cbd3cc1a28 100644 --- a/tracing/tests/span.rs +++ b/tracing/tests/span.rs @@ -62,12 +62,12 @@ fn handles_to_different_spans_with_the_same_metadata_are_not_equal() { #[test] fn spans_always_go_to_the_subscriber_that_tagged_them() { let collector1 = collector::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run(); let collector2 = collector::mock().run(); @@ -89,12 +89,12 @@ fn spans_always_go_to_the_subscriber_that_tagged_them() { #[test] fn spans_always_go_to_the_subscriber_that_tagged_them_even_across_threads() { let collector1 = collector::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run(); let foo = with_default(collector1, || { let foo = tracing::span!(Level::TRACE, "foo"); @@ -117,10 +117,10 @@ fn spans_always_go_to_the_subscriber_that_tagged_them_even_across_threads() { #[test] fn dropping_a_span_calls_drop_span() { let (collector, handle) = collector::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { let span = tracing::span!(Level::TRACE, "foo"); @@ -135,11 +135,11 @@ fn dropping_a_span_calls_drop_span() { #[test] fn span_closes_after_event() { let (collector, handle) = collector::mock() - .enter(span::mock().named("foo")) - .event(event::mock()) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect()) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { tracing::span!(Level::TRACE, "foo").in_scope(|| { @@ -154,14 +154,14 @@ fn span_closes_after_event() { #[test] fn new_span_after_event() { let (collector, handle) = collector::mock() - .enter(span::mock().named("foo")) - .event(event::mock()) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .enter(span::mock().named("bar")) - .exit(span::mock().named("bar")) - .drop_span(span::mock().named("bar")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect()) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .enter(span::expect().named("bar")) + .exit(span::expect().named("bar")) + .drop_span(span::expect().named("bar")) + .only() .run_with_handle(); with_default(collector, || { tracing::span!(Level::TRACE, "foo").in_scope(|| { @@ -177,11 +177,11 @@ fn new_span_after_event() { #[test] fn event_outside_of_span() { let (collector, handle) = collector::mock() - .event(event::mock()) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .event(event::expect()) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { tracing::debug!("my tracing::event!"); @@ -195,7 +195,7 @@ fn event_outside_of_span() { #[test] fn cloning_a_span_calls_clone_span() { let (collector, handle) = collector::mock() - .clone_span(span::mock().named("foo")) + .clone_span(span::expect().named("foo")) .run_with_handle(); with_default(collector, || { let span = tracing::span!(Level::TRACE, "foo"); @@ -211,9 +211,9 @@ fn cloning_a_span_calls_clone_span() { #[test] fn drop_span_when_exiting_dispatchers_context() { let (collector, handle) = collector::mock() - .clone_span(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) + .clone_span(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .run_with_handle(); with_default(collector, || { let span = tracing::span!(Level::TRACE, "foo"); @@ -228,15 +228,15 @@ fn drop_span_when_exiting_dispatchers_context() { #[test] fn clone_and_drop_span_always_go_to_the_subscriber_that_tagged_the_span() { let (subscriber1, handle1) = collector::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .clone_span(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .clone_span(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .run_with_handle(); - let subscriber2 = collector::mock().done().run(); + let subscriber2 = collector::mock().only().run(); let foo = with_default(subscriber1, || { let foo = tracing::span!(Level::TRACE, "foo"); @@ -259,10 +259,10 @@ fn clone_and_drop_span_always_go_to_the_subscriber_that_tagged_the_span() { #[test] fn span_closes_when_exited() { let (collector, handle) = collector::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { let foo = tracing::span!(Level::TRACE, "foo"); @@ -279,11 +279,11 @@ fn span_closes_when_exited() { #[test] fn enter() { let (collector, handle) = collector::mock() - .enter(span::mock().named("foo")) - .event(event::mock()) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect()) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { let foo = tracing::span!(Level::TRACE, "foo"); @@ -298,11 +298,11 @@ fn enter() { #[test] fn entered() { let (collector, handle) = collector::mock() - .enter(span::mock().named("foo")) - .event(event::mock()) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect()) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { let _span = tracing::span!(Level::TRACE, "foo").entered(); @@ -316,11 +316,11 @@ fn entered() { #[test] fn entered_api() { let (collector, handle) = collector::mock() - .enter(span::mock().named("foo")) - .event(event::mock()) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect()) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { let span = tracing::span!(Level::TRACE, "foo").entered(); @@ -337,16 +337,16 @@ fn entered_api() { fn moved_field() { let (collector, handle) = collector::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("bar") + span::expect().named("foo").with_field( + field::expect("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { let from = "my span"; @@ -366,11 +366,11 @@ fn moved_field() { fn dotted_field_name() { let (collector, handle) = collector::mock() .new_span( - span::mock() + span::expect() .named("foo") - .with_field(field::mock("fields.bar").with_value(&true).only()), + .with_field(field::expect("fields.bar").with_value(&true).only()), ) - .done() + .only() .run_with_handle(); with_default(collector, || { tracing::span!(Level::TRACE, "foo", fields.bar = true); @@ -384,16 +384,16 @@ fn dotted_field_name() { fn borrowed_field() { let (collector, handle) = collector::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("bar") + span::expect().named("foo").with_field( + field::expect("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { @@ -427,17 +427,17 @@ fn move_field_out_of_struct() { }; let (collector, handle) = collector::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("x") + span::expect().named("foo").with_field( + field::expect("x") .with_value(&debug(3.234)) - .and(field::mock("y").with_value(&debug(-1.223))) + .and(field::expect("y").with_value(&debug(-1.223))) .only(), ), ) .new_span( - span::mock() + span::expect() .named("bar") - .with_field(field::mock("position").with_value(&debug(&pos)).only()), + .with_field(field::expect("position").with_value(&debug(&pos)).only()), ) .run_with_handle(); @@ -460,10 +460,10 @@ fn move_field_out_of_struct() { fn float_values() { let (collector, handle) = collector::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("x") + span::expect().named("foo").with_field( + field::expect("x") .with_value(&3.234) - .and(field::mock("y").with_value(&-1.223)) + .and(field::expect("y").with_value(&-1.223)) .only(), ), ) @@ -487,17 +487,17 @@ fn add_field_after_new_span() { .new_span( span::mock() .named("foo") - .with_field(field::mock("bar").with_value(&5) - .and(field::mock("baz").with_value).only()), + .with_field(field::expect("bar").with_value(&5) + .and(field::expect("baz").with_value).only()), ) .record( span::mock().named("foo"), - field::mock("baz").with_value(&true).only(), + field::expect("baz").with_value(&true).only(), ) .enter(span::mock().named("foo")) .exit(span::mock().named("foo")) .drop_span(span::mock().named("foo")) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -516,16 +516,16 @@ fn add_fields_only_after_new_span() { .new_span(span::mock().named("foo")) .record( span::mock().named("foo"), - field::mock("bar").with_value(&5).only(), + field::expect("bar").with_value(&5).only(), ) .record( span::mock().named("foo"), - field::mock("baz").with_value(&true).only(), + field::expect("baz").with_value(&true).only(), ) .enter(span::mock().named("foo")) .exit(span::mock().named("foo")) .drop_span(span::mock().named("foo")) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -544,21 +544,21 @@ fn add_fields_only_after_new_span() { fn record_new_value_for_field() { let (collector, handle) = collector::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("bar") + span::expect().named("foo").with_field( + field::expect("bar") .with_value(&5) - .and(field::mock("baz").with_value(&false)) + .and(field::expect("baz").with_value(&false)) .only(), ), ) .record( - span::mock().named("foo"), - field::mock("baz").with_value(&true).only(), + span::expect().named("foo"), + field::expect("baz").with_value(&true).only(), ) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { @@ -575,25 +575,25 @@ fn record_new_value_for_field() { fn record_new_values_for_fields() { let (collector, handle) = collector::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("bar") + span::expect().named("foo").with_field( + field::expect("bar") .with_value(&4) - .and(field::mock("baz").with_value(&false)) + .and(field::expect("baz").with_value(&false)) .only(), ), ) .record( - span::mock().named("foo"), - field::mock("bar").with_value(&5).only(), + span::expect().named("foo"), + field::expect("bar").with_value(&5).only(), ) .record( - span::mock().named("foo"), - field::mock("baz").with_value(&true).only(), + span::expect().named("foo"), + field::expect("baz").with_value(&true).only(), ) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { @@ -611,12 +611,12 @@ fn record_new_values_for_fields() { fn new_span_with_target_and_log_level() { let (collector, handle) = collector::mock() .new_span( - span::mock() + span::expect() .named("foo") .with_target("app_span") .at_level(Level::DEBUG), ) - .done() + .only() .run_with_handle(); with_default(collector, || { @@ -630,8 +630,8 @@ fn new_span_with_target_and_log_level() { #[test] fn explicit_root_span_is_root() { let (collector, handle) = collector::mock() - .new_span(span::mock().named("foo").with_explicit_parent(None)) - .done() + .new_span(span::expect().named("foo").with_explicit_parent(None)) + .only() .run_with_handle(); with_default(collector, || { @@ -645,11 +645,11 @@ fn explicit_root_span_is_root() { #[test] fn explicit_root_span_is_root_regardless_of_ctx() { let (collector, handle) = collector::mock() - .new_span(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .new_span(span::mock().named("bar").with_explicit_parent(None)) - .exit(span::mock().named("foo")) - .done() + .new_span(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .new_span(span::expect().named("bar").with_explicit_parent(None)) + .exit(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { @@ -665,9 +665,13 @@ fn explicit_root_span_is_root_regardless_of_ctx() { #[test] fn explicit_child() { let (collector, handle) = collector::mock() - .new_span(span::mock().named("foo")) - .new_span(span::mock().named("bar").with_explicit_parent(Some("foo"))) - .done() + .new_span(span::expect().named("foo")) + .new_span( + span::expect() + .named("bar") + .with_explicit_parent(Some("foo")), + ) + .only() .run_with_handle(); with_default(collector, || { @@ -682,13 +686,13 @@ fn explicit_child() { #[test] fn explicit_child_at_levels() { let (collector, handle) = collector::mock() - .new_span(span::mock().named("foo")) - .new_span(span::mock().named("a").with_explicit_parent(Some("foo"))) - .new_span(span::mock().named("b").with_explicit_parent(Some("foo"))) - .new_span(span::mock().named("c").with_explicit_parent(Some("foo"))) - .new_span(span::mock().named("d").with_explicit_parent(Some("foo"))) - .new_span(span::mock().named("e").with_explicit_parent(Some("foo"))) - .done() + .new_span(span::expect().named("foo")) + .new_span(span::expect().named("a").with_explicit_parent(Some("foo"))) + .new_span(span::expect().named("b").with_explicit_parent(Some("foo"))) + .new_span(span::expect().named("c").with_explicit_parent(Some("foo"))) + .new_span(span::expect().named("d").with_explicit_parent(Some("foo"))) + .new_span(span::expect().named("e").with_explicit_parent(Some("foo"))) + .only() .run_with_handle(); with_default(collector, || { @@ -707,12 +711,16 @@ fn explicit_child_at_levels() { #[test] fn explicit_child_regardless_of_ctx() { let (collector, handle) = collector::mock() - .new_span(span::mock().named("foo")) - .new_span(span::mock().named("bar")) - .enter(span::mock().named("bar")) - .new_span(span::mock().named("baz").with_explicit_parent(Some("foo"))) - .exit(span::mock().named("bar")) - .done() + .new_span(span::expect().named("foo")) + .new_span(span::expect().named("bar")) + .enter(span::expect().named("bar")) + .new_span( + span::expect() + .named("baz") + .with_explicit_parent(Some("foo")), + ) + .exit(span::expect().named("bar")) + .only() .run_with_handle(); with_default(collector, || { @@ -728,8 +736,8 @@ fn explicit_child_regardless_of_ctx() { #[test] fn contextual_root() { let (collector, handle) = collector::mock() - .new_span(span::mock().named("foo").with_contextual_parent(None)) - .done() + .new_span(span::expect().named("foo").with_contextual_parent(None)) + .only() .run_with_handle(); with_default(collector, || { @@ -743,15 +751,15 @@ fn contextual_root() { #[test] fn contextual_child() { let (collector, handle) = collector::mock() - .new_span(span::mock().named("foo")) - .enter(span::mock().named("foo")) + .new_span(span::expect().named("foo")) + .enter(span::expect().named("foo")) .new_span( - span::mock() + span::expect() .named("bar") .with_contextual_parent(Some("foo")), ) - .exit(span::mock().named("foo")) - .done() + .exit(span::expect().named("foo")) + .only() .run_with_handle(); with_default(collector, || { @@ -768,13 +776,13 @@ fn contextual_child() { fn display_shorthand() { let (collector, handle) = collector::mock() .new_span( - span::mock().named("my_span").with_field( - field::mock("my_field") + span::expect().named("my_span").with_field( + field::expect("my_field") .with_value(&display("hello world")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(collector, || { tracing::span!(Level::TRACE, "my_span", my_field = %"hello world"); @@ -788,13 +796,13 @@ fn display_shorthand() { fn debug_shorthand() { let (collector, handle) = collector::mock() .new_span( - span::mock().named("my_span").with_field( - field::mock("my_field") + span::expect().named("my_span").with_field( + field::expect("my_field") .with_value(&debug("hello world")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(collector, || { tracing::span!(Level::TRACE, "my_span", my_field = ?"hello world"); @@ -808,14 +816,14 @@ fn debug_shorthand() { fn both_shorthands() { let (collector, handle) = collector::mock() .new_span( - span::mock().named("my_span").with_field( - field::mock("display_field") + span::expect().named("my_span").with_field( + field::expect("display_field") .with_value(&display("hello world")) - .and(field::mock("debug_field").with_value(&debug("hello world"))) + .and(field::expect("debug_field").with_value(&debug("hello world"))) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(collector, || { tracing::span!(Level::TRACE, "my_span", display_field = %"hello world", debug_field = ?"hello world");