1 #![allow(missing_docs)]
2 use super::{field, metadata, span, Parent};
3
4 use std::fmt;
5
6 /// A mock event.
7 ///
8 /// This is intended for use with the mock subscriber API in the
9 /// `subscriber` module.
10 #[derive(Default, Eq, PartialEq)]
11 pub struct MockEvent {
12 pub fields: Option<field::Expect>,
13 in_spans: Vec<span::MockSpan>,
14 pub(crate) parent: Option<Parent>,
15 metadata: metadata::Expect,
16 }
17
mock() -> MockEvent18 pub fn mock() -> MockEvent {
19 MockEvent {
20 ..Default::default()
21 }
22 }
23
msg(message: impl fmt::Display) -> MockEvent24 pub fn msg(message: impl fmt::Display) -> MockEvent {
25 mock().with_fields(field::msg(message))
26 }
27
28 impl MockEvent {
named<I>(self, name: I) -> Self where I: Into<String>,29 pub fn named<I>(self, name: I) -> Self
30 where
31 I: Into<String>,
32 {
33 Self {
34 metadata: metadata::Expect {
35 name: Some(name.into()),
36 ..self.metadata
37 },
38 ..self
39 }
40 }
41
with_fields<I>(self, fields: I) -> Self where I: Into<field::Expect>,42 pub fn with_fields<I>(self, fields: I) -> Self
43 where
44 I: Into<field::Expect>,
45 {
46 Self {
47 fields: Some(fields.into()),
48 ..self
49 }
50 }
51
at_level(self, level: tracing::Level) -> Self52 pub fn at_level(self, level: tracing::Level) -> Self {
53 Self {
54 metadata: metadata::Expect {
55 level: Some(level),
56 ..self.metadata
57 },
58 ..self
59 }
60 }
61
with_target<I>(self, target: I) -> Self where I: Into<String>,62 pub fn with_target<I>(self, target: I) -> Self
63 where
64 I: Into<String>,
65 {
66 Self {
67 metadata: metadata::Expect {
68 target: Some(target.into()),
69 ..self.metadata
70 },
71 ..self
72 }
73 }
74
with_explicit_parent(self, parent: Option<&str>) -> MockEvent75 pub fn with_explicit_parent(self, parent: Option<&str>) -> MockEvent {
76 let parent = match parent {
77 Some(name) => Parent::Explicit(name.into()),
78 None => Parent::ExplicitRoot,
79 };
80 Self {
81 parent: Some(parent),
82 ..self
83 }
84 }
85
check( &mut self, event: &tracing::Event<'_>, get_parent_name: impl FnOnce() -> Option<String>, subscriber_name: &str, )86 pub fn check(
87 &mut self,
88 event: &tracing::Event<'_>,
89 get_parent_name: impl FnOnce() -> Option<String>,
90 subscriber_name: &str,
91 ) {
92 let meta = event.metadata();
93 let name = meta.name();
94 self.metadata
95 .check(meta, format_args!("event \"{}\"", name), subscriber_name);
96 assert!(
97 meta.is_event(),
98 "[{}] expected {}, but got {:?}",
99 subscriber_name,
100 self,
101 event
102 );
103 if let Some(ref mut expected_fields) = self.fields {
104 let mut checker = expected_fields.checker(name, subscriber_name);
105 event.record(&mut checker);
106 checker.finish();
107 }
108
109 if let Some(ref expected_parent) = self.parent {
110 let actual_parent = get_parent_name();
111 expected_parent.check_parent_name(
112 actual_parent.as_deref(),
113 event.parent().cloned(),
114 event.metadata().name(),
115 subscriber_name,
116 )
117 }
118 }
119
in_scope(self, spans: impl IntoIterator<Item = span::MockSpan>) -> Self120 pub fn in_scope(self, spans: impl IntoIterator<Item = span::MockSpan>) -> Self {
121 Self {
122 in_spans: spans.into_iter().collect(),
123 ..self
124 }
125 }
126
scope_mut(&mut self) -> &mut [span::MockSpan]127 pub fn scope_mut(&mut self) -> &mut [span::MockSpan] {
128 &mut self.in_spans[..]
129 }
130 }
131
132 impl fmt::Display for MockEvent {
fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result133 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
134 write!(f, "an event{}", self.metadata)
135 }
136 }
137
138 impl fmt::Debug for MockEvent {
fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result139 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
140 let mut s = f.debug_struct("MockEvent");
141
142 if let Some(ref name) = self.metadata.name {
143 s.field("name", name);
144 }
145
146 if let Some(ref target) = self.metadata.target {
147 s.field("target", target);
148 }
149
150 if let Some(ref level) = self.metadata.level {
151 s.field("level", &format_args!("{:?}", level));
152 }
153
154 if let Some(ref fields) = self.fields {
155 s.field("fields", fields);
156 }
157
158 if let Some(ref parent) = self.parent {
159 s.field("parent", &format_args!("{:?}", parent));
160 }
161
162 if !self.in_spans.is_empty() {
163 s.field("in_spans", &self.in_spans);
164 }
165
166 s.finish()
167 }
168 }
169