vendor/tracing/tests/support/span.rs

   1 #![allow(missing_docs)]
   2 use super::{field, metadata, Parent};
   3 use std::fmt;
   4
   5 /// A mock span.
   6 ///
   7 /// This is intended for use with the mock subscriber API in the
   8 /// `subscriber` module.
   9 #[derive(Clone, Debug, Default, Eq, PartialEq)]
  10 pub struct MockSpan {
  11     pub(in crate::support) metadata: metadata::Expect,
  12 }
  13
  14 #[derive(Debug, Default, Eq, PartialEq)]
  15 pub struct NewSpan {
  16     pub(in crate::support) span: MockSpan,
  17     pub(in crate::support) fields: field::Expect,
  18     pub(in crate::support) parent: Option<Parent>,
  19 }
  20
  21 pub fn mock() -> MockSpan {
  22     MockSpan {
  23         ..Default::default()
  24     }
  25 }
  26
  27 impl MockSpan {
  28     pub fn named<I>(self, name: I) -> Self
  29     where
  30         I: Into<String>,
  31     {
  32         Self {
  33             metadata: metadata::Expect {
  34                 name: Some(name.into()),
  35                 ..self.metadata
  36             },
  37         }
  38     }
  39
  40     pub fn at_level(self, level: tracing::Level) -> Self {
  41         Self {
  42             metadata: metadata::Expect {
  43                 level: Some(level),
  44                 ..self.metadata
  45             },
  46         }
  47     }
  48
  49     pub fn with_target<I>(self, target: I) -> Self
  50     where
  51         I: Into<String>,
  52     {
  53         Self {
  54             metadata: metadata::Expect {
  55                 target: Some(target.into()),
  56                 ..self.metadata
  57             },
  58         }
  59     }
  60
  61     pub fn with_explicit_parent(self, parent: Option<&str>) -> NewSpan {
  62         let parent = match parent {
  63             Some(name) => Parent::Explicit(name.into()),
  64             None => Parent::ExplicitRoot,
  65         };
  66         NewSpan {
  67             parent: Some(parent),
  68             span: self,
  69             ..Default::default()
  70         }
  71     }
  72
  73     pub fn with_contextual_parent(self, parent: Option<&str>) -> NewSpan {
  74         let parent = match parent {
  75             Some(name) => Parent::Contextual(name.into()),
  76             None => Parent::ContextualRoot,
  77         };
  78         NewSpan {
  79             parent: Some(parent),
  80             span: self,
  81             ..Default::default()
  82         }
  83     }
  84
  85     pub fn name(&self) -> Option<&str> {
  86         self.metadata.name.as_ref().map(String::as_ref)
  87     }
  88
  89     pub fn with_field<I>(self, fields: I) -> NewSpan
  90     where
  91         I: Into<field::Expect>,
  92     {
  93         NewSpan {
  94             span: self,
  95             fields: fields.into(),
  96             ..Default::default()
  97         }
  98     }
  99
 100     pub(in crate::support) fn check_metadata(&self, actual: &tracing::Metadata<'_>) {
 101         self.metadata.check(actual, format_args!("span {}", self));
 102         assert!(actual.is_span(), "expected a span but got {:?}", actual);
 103     }
 104 }
 105
 106 impl fmt::Display for MockSpan {
 107     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 108         if self.metadata.name.is_some() {
 109             write!(f, "a span{}", self.metadata)
 110         } else {
 111             write!(f, "any span{}", self.metadata)
 112         }
 113     }
 114 }
 115
 116 impl From<MockSpan> for NewSpan {
 117     fn from(span: MockSpan) -> Self {
 118         Self {
 119             span,
 120             ..Default::default()
 121         }
 122     }
 123 }
 124
 125 impl NewSpan {
 126     pub fn with_explicit_parent(self, parent: Option<&str>) -> NewSpan {
 127         let parent = match parent {
 128             Some(name) => Parent::Explicit(name.into()),
 129             None => Parent::ExplicitRoot,
 130         };
 131         NewSpan {
 132             parent: Some(parent),
 133             ..self
 134         }
 135     }
 136
 137     pub fn with_contextual_parent(self, parent: Option<&str>) -> NewSpan {
 138         let parent = match parent {
 139             Some(name) => Parent::Contextual(name.into()),
 140             None => Parent::ContextualRoot,
 141         };
 142         NewSpan {
 143             parent: Some(parent),
 144             ..self
 145         }
 146     }
 147
 148     pub fn with_field<I>(self, fields: I) -> NewSpan
 149     where
 150         I: Into<field::Expect>,
 151     {
 152         NewSpan {
 153             fields: fields.into(),
 154             ..self
 155         }
 156     }
 157 }
 158
 159 impl fmt::Display for NewSpan {
 160     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 161         write!(f, "a new span{}", self.span.metadata)?;
 162         if !self.fields.is_empty() {
 163             write!(f, " with {}", self.fields)?;
 164         }
 165         Ok(())
 166     }
 167 }