vendor/tracing-attributes/tests/err.rs

   1 #[path = "../../tracing-futures/tests/support.rs"]
   2 // we don't use some of the test support functions, but `tracing-futures` does.
   3 #[allow(dead_code)]
   4 mod support;
   5 use support::*;
   6
   7 use tracing::subscriber::with_default;
   8 use tracing::Level;
   9 use tracing_attributes::instrument;
  10
  11 use std::convert::TryFrom;
  12 use std::num::TryFromIntError;
  13
  14 #[instrument(err)]
  15 fn err() -> Result<u8, TryFromIntError> {
  16     u8::try_from(1234)
  17 }
  18
  19 #[test]
  20 fn test() {
  21     let span = span::mock().named("err");
  22     let (subscriber, handle) = subscriber::mock()
  23         .new_span(span.clone())
  24         .enter(span.clone())
  25         .event(event::mock().at_level(Level::ERROR))
  26         .exit(span.clone())
  27         .drop_span(span)
  28         .done()
  29         .run_with_handle();
  30     with_default(subscriber, || err().ok());
  31     handle.assert_finished();
  32 }
  33
  34 #[instrument(err)]
  35 async fn err_async(polls: usize) -> Result<u8, TryFromIntError> {
  36     let future = PollN::new_ok(polls);
  37     tracing::trace!(awaiting = true);
  38     future.await.ok();
  39     u8::try_from(1234)
  40 }
  41
  42 #[test]
  43 fn test_async() {
  44     let span = span::mock().named("err_async");
  45     let (subscriber, handle) = subscriber::mock()
  46         .new_span(span.clone())
  47         .enter(span.clone())
  48         .event(
  49             event::mock()
  50                 .with_fields(field::mock("awaiting").with_value(&true))
  51                 .at_level(Level::TRACE),
  52         )
  53         .exit(span.clone())
  54         .enter(span.clone())
  55         .event(event::mock().at_level(Level::ERROR))
  56         .exit(span.clone())
  57         .drop_span(span)
  58         .done()
  59         .run_with_handle();
  60     with_default(subscriber, || {
  61         block_on_future(async { err_async(2).await }).ok();
  62     });
  63     handle.assert_finished();
  64 }
  65
  66 #[instrument(err)]
  67 fn err_mut(out: &mut u8) -> Result<(), TryFromIntError> {
  68     *out = u8::try_from(1234)?;
  69     Ok(())
  70 }
  71
  72 #[test]
  73 fn test_mut() {
  74     let span = span::mock().named("err_mut");
  75     let (subscriber, handle) = subscriber::mock()
  76         .new_span(span.clone())
  77         .enter(span.clone())
  78         .event(event::mock().at_level(Level::ERROR))
  79         .exit(span.clone())
  80         .drop_span(span)
  81         .done()
  82         .run_with_handle();
  83     with_default(subscriber, || err_mut(&mut 0).ok());
  84     handle.assert_finished();
  85 }
  86
  87 #[instrument(err)]
  88 async fn err_mut_async(polls: usize, out: &mut u8) -> Result<(), TryFromIntError> {
  89     let future = PollN::new_ok(polls);
  90     tracing::trace!(awaiting = true);
  91     future.await.ok();
  92     *out = u8::try_from(1234)?;
  93     Ok(())
  94 }
  95
  96 #[test]
  97 fn test_mut_async() {
  98     let span = span::mock().named("err_mut_async");
  99     let (subscriber, handle) = subscriber::mock()
 100         .new_span(span.clone())
 101         .enter(span.clone())
 102         .event(
 103             event::mock()
 104                 .with_fields(field::mock("awaiting").with_value(&true))
 105                 .at_level(Level::TRACE),
 106         )
 107         .exit(span.clone())
 108         .enter(span.clone())
 109         .event(event::mock().at_level(Level::ERROR))
 110         .exit(span.clone())
 111         .drop_span(span)
 112         .done()
 113         .run_with_handle();
 114     with_default(subscriber, || {
 115         block_on_future(async { err_mut_async(2, &mut 0).await }).ok();
 116     });
 117     handle.assert_finished();
 118 }
 119
 120 #[test]
 121 fn impl_trait_return_type() {
 122     // Reproduces https://github.com/tokio-rs/tracing/issues/1227
 123
 124     #[instrument(err)]
 125     fn returns_impl_trait(x: usize) -> Result<impl Iterator<Item = usize>, String> {
 126         Ok(0..x)
 127     }
 128
 129     let span = span::mock().named("returns_impl_trait");
 130
 131     let (subscriber, handle) = subscriber::mock()
 132         .new_span(
 133             span.clone()
 134                 .with_field(field::mock("x").with_value(&format_args!("10")).only()),
 135         )
 136         .enter(span.clone())
 137         .exit(span.clone())
 138         .drop_span(span)
 139         .done()
 140         .run_with_handle();
 141
 142     with_default(subscriber, || {
 143         for _ in returns_impl_trait(10).unwrap() {
 144             // nop
 145         }
 146     });
 147
 148     handle.assert_finished();
 149 }