expect_json/expect/mod.rs
1pub mod ops;
2
3use crate::expect::ops::ExpectArray;
4use crate::expect::ops::ExpectEmail;
5use crate::expect::ops::ExpectFloat;
6use crate::expect::ops::ExpectInteger;
7use crate::expect::ops::ExpectIsoDateTime;
8use crate::expect::ops::ExpectObject;
9use crate::expect::ops::ExpectString;
10use crate::expect::ops::ExpectUuid;
11
12///
13/// Expect a JSON object. See [`ExpectObject`] for further methods to
14/// define what is expected. Such as the range it is expected to be within,
15/// or if it should be positive or negative.
16///
17/// ```rust
18/// # async fn test() -> Result<(), Box<dyn ::std::error::Error>> {
19/// #
20/// # use axum::Router;
21/// # use axum::extract::Json;
22/// # use axum::routing::get;
23/// # use axum_test::TestServer;
24/// # use serde_json::json;
25/// #
26/// # let server = TestServer::new(Router::new())?;
27/// #
28/// use axum_test::expect_json;
29///
30/// let server = TestServer::new(Router::new())?;
31///
32/// server.get(&"/user/barrington")
33/// .await
34/// .assert_json(&json!({
35/// "name": "Barrington",
36/// "metadata": expect_json::object().contains(json!({
37/// "age": expect_json::integer().in_range(18..=100),
38/// "email": expect_json::email(),
39/// })),
40/// }));
41/// #
42/// # Ok(()) }
43/// ```
44pub fn object() -> ExpectObject {
45 ExpectObject::new()
46}
47
48///
49/// Expect a floating point number. See [`ExpectFloat`] for further methods to
50/// define what is expected. Such as the range it is expected to be within,
51/// or if it should be positive or negative.
52///
53/// ```rust
54/// # async fn test() -> Result<(), Box<dyn ::std::error::Error>> {
55/// #
56/// # use axum::Router;
57/// # use axum::extract::Json;
58/// # use axum::routing::get;
59/// # use axum_test::TestServer;
60/// # use serde_json::json;
61/// #
62/// # let server = TestServer::new(Router::new())?;
63/// #
64/// use axum_test::expect_json;
65///
66/// let server = TestServer::new(Router::new())?;
67///
68/// server.get(&"/user/barrington")
69/// .await
70/// .assert_json(&json!({
71/// "name": "Barrington",
72/// "height_in_meters": expect_json::float().in_range(0.5..=2.5),
73/// }));
74/// #
75/// # Ok(()) }
76/// ```
77pub fn float() -> ExpectFloat {
78 ExpectFloat::new()
79}
80
81///
82/// Expects an integer. See [`ExpectInteger`] for further methods to
83/// define what is expected. Such as the range it is expected to be within,
84/// or if it should be positive or negative.
85///
86/// ```rust
87/// # async fn test() -> Result<(), Box<dyn ::std::error::Error>> {
88/// #
89/// # use axum::Router;
90/// # use axum::extract::Json;
91/// # use axum::routing::get;
92/// # use axum_test::TestServer;
93/// # use serde_json::json;
94/// #
95/// # let server = TestServer::new(Router::new())?;
96/// #
97/// use axum_test::expect_json;
98///
99/// let server = TestServer::new(Router::new())?;
100///
101/// server.get(&"/user/barrington")
102/// .await
103/// .assert_json(&json!({
104/// "name": "Barrington",
105/// "age": expect_json::integer().in_range(18..=110),
106/// }));
107/// #
108/// # Ok(()) }
109/// ```
110pub fn integer() -> ExpectInteger {
111 ExpectInteger::new()
112}
113
114///
115/// Expect a string. See [`ExpectString`] for further methods to defined
116/// the length, and partial contents, that is expected.
117///
118/// ```rust
119/// # async fn test() -> Result<(), Box<dyn ::std::error::Error>> {
120/// #
121/// # use axum::Router;
122/// # use axum::extract::Json;
123/// # use axum::routing::get;
124/// # use axum_test::TestServer;
125/// # use serde_json::json;
126/// #
127/// # let server = TestServer::new(Router::new())?;
128/// #
129/// use axum_test::expect_json;
130///
131/// let server = TestServer::new(Router::new())?;
132///
133/// server.get(&"/user/barrington")
134/// .await
135/// .assert_json(&json!({
136/// "name": "Barrington",
137/// "metadata": expect_json::object().contains(json!({
138/// "age": expect_json::integer().in_range(18..=100),
139/// "email": expect_json::email(),
140/// })),
141/// }));
142/// #
143/// # Ok(()) }
144/// ```
145pub fn string() -> ExpectString {
146 ExpectString::new()
147}
148
149///
150/// Expects a JSON array. The returned [`ExpectArray`] has methods to
151/// defined the length, uniqueness, all values meet a condition, etc,
152/// that is expected to be returned.
153///
154/// ```rust
155/// # async fn test() -> Result<(), Box<dyn ::std::error::Error>> {
156/// #
157/// # use axum::Router;
158/// # use axum::extract::Json;
159/// # use axum::routing::get;
160/// # use axum_test::TestServer;
161/// # use serde_json::json;
162/// #
163/// # let server = TestServer::new(Router::new())?;
164/// #
165/// use axum_test::expect_json;
166///
167/// let server = TestServer::new(Router::new())?;
168///
169/// server.get(&"/user/barrington")
170/// .await
171/// .assert_json(&json!({
172/// "name": "Barrington",
173/// "tags": expect_json::array().all(expect_json::string()),
174/// }));
175/// #
176/// # Ok(()) }
177/// ```
178pub fn array() -> ExpectArray {
179 ExpectArray::new()
180}
181
182///
183/// Expect a valid-looking ISO date time.
184///
185/// Further methods are available on the returned [`ExpectIsoDateTime`]
186/// to check if the time is within certain durations, the time zone, etc.
187///
188/// ```rust
189/// # async fn test() -> Result<(), Box<dyn ::std::error::Error>> {
190/// #
191/// # use axum::Router;
192/// # use axum::extract::Json;
193/// # use axum::routing::get;
194/// # use axum_test::TestServer;
195/// # use serde_json::json;
196/// #
197/// # let server = TestServer::new(Router::new())?;
198/// #
199/// use axum_test::expect_json;
200/// use std::time::Duration;
201///
202/// let server = TestServer::new(Router::new())?;
203///
204/// server.get(&"/user/barrington")
205/// .await
206/// .assert_json(&json!({
207/// "name": "Barrington",
208/// "created_at": expect_json::iso_date_time().within_past(Duration::from_secs(60)),
209/// }));
210/// #
211/// # Ok(()) }
212/// ```
213pub fn iso_date_time() -> ExpectIsoDateTime {
214 ExpectIsoDateTime::new()
215}
216
217///
218/// Expect a valid UUID.
219///
220/// ```rust
221/// # async fn test() -> Result<(), Box<dyn ::std::error::Error>> {
222/// #
223/// # use axum::Router;
224/// # use axum::extract::Json;
225/// # use axum::routing::get;
226/// # use axum_test::TestServer;
227/// # use serde_json::json;
228/// #
229/// # let server = TestServer::new(Router::new())?;
230/// #
231/// use std::time::Duration;
232/// use axum_test::expect_json;
233///
234/// let server = TestServer::new(Router::new())?;
235///
236/// server.get(&"/user/alice")
237/// .await
238/// .assert_json(&json!({
239/// "name": "Alice",
240/// "id": expect_json::uuid(),
241/// }));
242/// #
243/// # Ok(()) }
244/// ```
245///
246pub fn uuid() -> ExpectUuid {
247 ExpectUuid::new()
248}
249
250///
251/// Expect a valid-looking email address.
252///
253/// It makes no guarantees if the address is actually registered or in use.
254///
255/// ```rust
256/// # async fn test() -> Result<(), Box<dyn ::std::error::Error>> {
257/// #
258/// # use axum::Router;
259/// # use axum::extract::Json;
260/// # use axum::routing::get;
261/// # use axum_test::TestServer;
262/// # use serde_json::json;
263/// #
264/// # let server = TestServer::new(Router::new())?;
265/// #
266/// use axum_test::expect_json;
267///
268/// let server = TestServer::new(Router::new())?;
269///
270/// server.get(&"/user")
271/// .await
272/// .assert_json(&json!({
273/// "name": "John Doe",
274/// "email": expect_json::email(),
275/// }));
276/// #
277/// # Ok(()) }
278/// ```
279pub fn email() -> ExpectEmail {
280 ExpectEmail::new()
281}