expect_json/expect/ops/expect_integer/
expect_integer.rs

1use crate::expect::ops::expect_integer::ExpectIntegerSubOp;
2use crate::expect_core::expect_op;
3use crate::expect_core::Context;
4use crate::expect_core::ExpectOp;
5use crate::expect_core::ExpectOpResult;
6use crate::JsonType;
7use core::ops::RangeBounds;
8
9#[expect_op(internal, name = "integer")]
10#[derive(Debug, Clone, Default, PartialEq)]
11pub struct ExpectInteger {
12    sub_ops: Vec<ExpectIntegerSubOp>,
13}
14
15impl ExpectInteger {
16    pub(crate) fn new() -> Self {
17        Self { sub_ops: vec![] }
18    }
19
20    ///
21    /// Expect an integer within the given range.
22    ///
23    /// ```rust
24    /// # async fn test() -> Result<(), Box<dyn ::std::error::Error>> {
25    /// #
26    /// # use axum::Router;
27    /// # use axum::extract::Json;
28    /// # use axum::routing::get;
29    /// # use axum_test::TestServer;
30    /// # use serde_json::json;
31    /// #
32    /// # let server = TestServer::new(Router::new())?;
33    /// #
34    /// use axum_test::expect_json;
35    ///
36    /// let server = TestServer::new(Router::new())?;
37    ///
38    /// server.get(&"/user/barrington")
39    ///     .await
40    ///     .assert_json(&json!({
41    ///         "name": "Barrington",
42    ///         "age": expect_json::integer().in_range(18..=110),
43    ///     }));
44    /// #
45    /// # Ok(()) }
46    /// ```
47    pub fn in_range<R>(mut self, range: R) -> Self
48    where
49        R: RangeBounds<i64>,
50    {
51        let min = range.start_bound().cloned();
52        let max = range.end_bound().cloned();
53
54        self.sub_ops.push(ExpectIntegerSubOp::InRange {
55            min: min.into(),
56            max: max.into(),
57        });
58
59        self
60    }
61
62    pub fn outside_range<R>(mut self, range: R) -> Self
63    where
64        R: RangeBounds<i64>,
65    {
66        let min = range.start_bound().cloned();
67        let max = range.end_bound().cloned();
68
69        self.sub_ops.push(ExpectIntegerSubOp::OutsideRange {
70            min: min.into(),
71            max: max.into(),
72        });
73
74        self
75    }
76
77    pub fn zero(mut self) -> Self {
78        self.sub_ops.push(ExpectIntegerSubOp::Zero);
79        self
80    }
81
82    pub fn not_zero(mut self) -> Self {
83        self.sub_ops.push(ExpectIntegerSubOp::NotZero);
84        self
85    }
86
87    pub fn positive(mut self) -> Self {
88        self.sub_ops.push(ExpectIntegerSubOp::Positive);
89        self
90    }
91
92    pub fn negative(mut self) -> Self {
93        self.sub_ops.push(ExpectIntegerSubOp::Negative);
94        self
95    }
96}
97
98impl ExpectOp for ExpectInteger {
99    fn on_i64(&self, context: &mut Context, received: i64) -> ExpectOpResult<()> {
100        for sub_op in &self.sub_ops {
101            sub_op.on_i64(self, context, received)?;
102        }
103
104        Ok(())
105    }
106
107    fn on_u64(&self, context: &mut Context, received: u64) -> ExpectOpResult<()> {
108        for sub_op in &self.sub_ops {
109            sub_op.on_u64(self, context, received)?;
110        }
111
112        Ok(())
113    }
114
115    fn debug_supported_types(&self) -> &'static [JsonType] {
116        &[JsonType::Integer]
117    }
118}
119
120#[cfg(test)]
121mod test_in_range {
122    use crate::expect;
123    use crate::expect_json_eq;
124    use pretty_assertions::assert_eq;
125    use serde_json::json;
126
127    #[test]
128    fn it_should_be_true_for_all_values_in_total_range() {
129        let left = json!(1);
130        let right = json!(expect::integer().in_range(..));
131        let output = expect_json_eq(&left, &right);
132        assert!(output.is_ok());
133
134        let left = json!(i64::MIN);
135        let right = json!(expect::integer().in_range(..));
136        let output = expect_json_eq(&left, &right);
137        assert!(output.is_ok());
138
139        let left = json!(u64::MAX);
140        let right = json!(expect::integer().in_range(..));
141        let output = expect_json_eq(&left, &right);
142        assert!(output.is_ok());
143    }
144
145    #[test]
146    fn it_should_be_true_for_all_values_in_partial_range() {
147        let left = json!(0);
148        let right = json!(expect::integer().in_range(-10..10));
149        let output = expect_json_eq(&left, &right);
150        assert!(output.is_ok());
151
152        let left = json!(-10);
153        let right = json!(expect::integer().in_range(-10..10));
154        let output = expect_json_eq(&left, &right);
155        assert!(output.is_ok());
156
157        let left = json!(5);
158        let right = json!(expect::integer().in_range(-10..10));
159        let output = expect_json_eq(&left, &right);
160        assert!(output.is_ok());
161    }
162
163    #[test]
164    fn it_should_be_false_for_all_values_out_of_range() {
165        let left = json!(1);
166        let right = json!(expect::integer().in_range(0..1));
167
168        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
169        assert_eq!(
170            output,
171            r#"Json expect::integer() error at root:
172    integer is not in range
173    expected 0..1
174    received 1"#
175        );
176
177        let left = json!(-11);
178        let right = json!(expect::integer().in_range(0..1));
179
180        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
181        assert_eq!(
182            output,
183            r#"Json expect::integer() error at root:
184    integer is not in range
185    expected 0..1
186    received -11"#
187        );
188    }
189
190    #[test]
191    fn it_should_be_true_for_value_in_inclusive_range() {
192        let left = json!(1);
193        let right = json!(expect::integer().in_range(0..=1));
194
195        let output = expect_json_eq(&left, &right);
196        assert!(output.is_ok());
197    }
198
199    #[test]
200    fn it_should_be_true_for_positive_value_with_negative_min() {
201        let left = json!(5);
202        let right = json!(expect::integer().in_range(-10..10));
203
204        let output = expect_json_eq(&left, &right);
205        assert!(output.is_ok());
206    }
207
208    #[test]
209    fn it_should_be_false_for_positive_value_outside_range_with_negative_min() {
210        let left = json!(11);
211        let right = json!(expect::integer().in_range(-10..10));
212
213        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
214        assert_eq!(
215            output,
216            r#"Json expect::integer() error at root:
217    integer is not in range
218    expected -10..10
219    received 11"#
220        );
221    }
222
223    #[test]
224    fn it_should_be_false_for_positive_value_outside_range_with_negative_range() {
225        let left = json!(11);
226        let right = json!(expect::integer().in_range(-10..-1));
227
228        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
229        assert_eq!(
230            output,
231            r#"Json expect::integer() error at root:
232    integer is not in range
233    expected -10..-1
234    received 11"#
235        );
236    }
237}
238
239#[cfg(test)]
240mod test_outside_range {
241    use crate::expect;
242    use crate::expect_json_eq;
243    use pretty_assertions::assert_eq;
244    use serde_json::json;
245
246    #[test]
247    fn it_should_be_false_for_all_values_in_total_range() {
248        let left = json!(1);
249        let right = json!(expect::integer().outside_range(..));
250        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
251        assert_eq!(
252            output,
253            r#"Json expect::integer() error at root:
254    integer is in range
255    expected ..
256    received 1"#
257        );
258
259        let left = json!(i64::MIN);
260        let right = json!(expect::integer().outside_range(..));
261        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
262        assert_eq!(
263            output,
264            r#"Json expect::integer() error at root:
265    integer is in range
266    expected ..
267    received -9223372036854775808"#
268        );
269
270        let left = json!(u64::MAX);
271        let right = json!(expect::integer().outside_range(..));
272        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
273        assert_eq!(
274            output,
275            r#"Json expect::integer() error at root:
276    integer is in range
277    expected ..
278    received 18446744073709551615"#
279        );
280    }
281
282    #[test]
283    fn it_should_be_false_for_all_values_overlapping_partial_ranges() {
284        let left = json!(0);
285        let right = json!(expect::integer().outside_range(-10..10));
286        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
287        assert_eq!(
288            output,
289            r#"Json expect::integer() error at root:
290    integer is in range
291    expected -10..10
292    received 0"#
293        );
294
295        let left = json!(-10);
296        let right = json!(expect::integer().outside_range(-10..10));
297        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
298        assert_eq!(
299            output,
300            r#"Json expect::integer() error at root:
301    integer is in range
302    expected -10..10
303    received -10"#
304        );
305
306        let left = json!(5);
307        let right = json!(expect::integer().outside_range(-10..10));
308        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
309        assert_eq!(
310            output,
311            r#"Json expect::integer() error at root:
312    integer is in range
313    expected -10..10
314    received 5"#
315        );
316    }
317
318    #[test]
319    fn it_should_be_true_for_all_values_out_of_range() {
320        let left = json!(1);
321        let right = json!(expect::integer().outside_range(0..1));
322
323        let output = expect_json_eq(&left, &right);
324        assert!(output.is_ok());
325
326        let left = json!(-11);
327        let right = json!(expect::integer().outside_range(0..1));
328
329        let output = expect_json_eq(&left, &right);
330        assert!(output.is_ok());
331    }
332
333    #[test]
334    fn it_should_be_false_for_value_in_inclusive_range() {
335        let left = json!(1);
336        let right = json!(expect::integer().outside_range(0..=1));
337
338        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
339        assert_eq!(
340            output,
341            r#"Json expect::integer() error at root:
342    integer is in range
343    expected 0..=1
344    received 1"#
345        );
346    }
347
348    #[test]
349    fn it_should_be_false_for_positive_value_with_negative_min() {
350        let left = json!(5);
351        let right = json!(expect::integer().outside_range(-10..10));
352
353        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
354        assert_eq!(
355            output,
356            r#"Json expect::integer() error at root:
357    integer is in range
358    expected -10..10
359    received 5"#
360        );
361    }
362
363    #[test]
364    fn it_should_be_true_for_positive_value_outside_range_with_negative_min() {
365        let left = json!(11);
366        let right = json!(expect::integer().outside_range(-10..10));
367
368        let output = expect_json_eq(&left, &right);
369        assert!(output.is_ok());
370    }
371
372    #[test]
373    fn it_should_be_true_for_positive_value_outside_range_with_negative_range() {
374        let left = json!(11);
375        let right = json!(expect::integer().outside_range(-10..-1));
376
377        let output = expect_json_eq(&left, &right);
378        assert!(output.is_ok());
379    }
380}
381
382#[cfg(test)]
383mod test_zero {
384    use crate::expect;
385    use crate::expect_json_eq;
386    use pretty_assertions::assert_eq;
387    use serde_json::json;
388
389    #[test]
390    fn it_should_be_true_for_zero() {
391        let left = json!(0);
392        let right = json!(expect::integer().zero());
393
394        let output = expect_json_eq(&left, &right);
395        assert!(output.is_ok());
396    }
397
398    #[test]
399    fn it_should_be_false_for_negative_value() {
400        let left = json!(-1);
401        let right = json!(expect::integer().zero());
402
403        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
404        assert_eq!(
405            output,
406            r#"Json expect::integer() error at root, is not zero:
407    expected 0
408    received -1"#
409        );
410    }
411
412    #[test]
413    fn it_should_be_false_for_negative_max() {
414        let left = json!(i64::MIN);
415        let right = json!(expect::integer().zero());
416
417        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
418        assert_eq!(
419            output,
420            r#"Json expect::integer() error at root, is not zero:
421    expected 0
422    received -9223372036854775808"#
423        );
424    }
425
426    #[test]
427    fn it_should_be_false_for_positive_value() {
428        let left = json!(1);
429        let right = json!(expect::integer().zero());
430
431        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
432        assert_eq!(
433            output,
434            r#"Json expect::integer() error at root, is not zero:
435    expected 0
436    received 1"#
437        );
438    }
439
440    #[test]
441    fn it_should_be_false_for_i64_max() {
442        let left = json!(i64::MAX);
443        let right = json!(expect::integer().zero());
444
445        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
446        assert_eq!(
447            output,
448            r#"Json expect::integer() error at root, is not zero:
449    expected 0
450    received 9223372036854775807"#
451        );
452    }
453
454    #[test]
455    fn it_should_be_false_for_u64_max() {
456        let left = json!(u64::MAX);
457        let right = json!(expect::integer().zero());
458
459        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
460        assert_eq!(
461            output,
462            r#"Json expect::integer() error at root, is not zero:
463    expected 0
464    received 18446744073709551615"#
465        );
466    }
467}
468
469#[cfg(test)]
470mod test_not_zero {
471    use crate::expect;
472    use crate::expect_json_eq;
473    use pretty_assertions::assert_eq;
474    use serde_json::json;
475
476    #[test]
477    fn it_should_be_false_for_zero() {
478        let left = json!(0);
479        let right = json!(expect::integer().not_zero());
480
481        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
482        assert_eq!(
483            output,
484            r#"Json expect::integer() error at root, is zero:
485    expected non-zero integer
486    received 0"#
487        );
488    }
489
490    #[test]
491    fn it_should_be_true_for_negative_value() {
492        let left = json!(-1);
493        let right = json!(expect::integer().not_zero());
494
495        let output = expect_json_eq(&left, &right);
496        assert!(output.is_ok());
497    }
498
499    #[test]
500    fn it_should_be_true_for_negative_max() {
501        let left = json!(i64::MIN);
502        let right = json!(expect::integer().not_zero());
503
504        let output = expect_json_eq(&left, &right);
505        assert!(output.is_ok());
506    }
507
508    #[test]
509    fn it_should_be_true_for_positive_value() {
510        let left = json!(1);
511        let right = json!(expect::integer().not_zero());
512
513        let output = expect_json_eq(&left, &right);
514        assert!(output.is_ok());
515    }
516
517    #[test]
518    fn it_should_be_true_for_i64_max() {
519        let left = json!(i64::MAX);
520        let right = json!(expect::integer().not_zero());
521
522        let output = expect_json_eq(&left, &right);
523        assert!(output.is_ok());
524    }
525
526    #[test]
527    fn it_should_be_true_for_u64_max() {
528        let left = json!(u64::MAX);
529        let right = json!(expect::integer().not_zero());
530
531        let output = expect_json_eq(&left, &right);
532        assert!(output.is_ok());
533    }
534}
535
536#[cfg(test)]
537mod test_positive {
538    use crate::expect;
539    use crate::expect_json_eq;
540    use pretty_assertions::assert_eq;
541    use serde_json::json;
542
543    #[test]
544    fn it_should_be_true_for_zero() {
545        let left = json!(0);
546        let right = json!(expect::integer().positive());
547
548        let output = expect_json_eq(&left, &right);
549        assert!(output.is_ok());
550    }
551
552    #[test]
553    fn it_should_be_false_for_negative_i64() {
554        let left = json!(-1);
555        let right = json!(expect::integer().positive());
556
557        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
558        assert_eq!(
559            output,
560            r#"Json expect::integer() error at root:
561    integer is not positive
562    received -1"#
563        );
564    }
565
566    #[test]
567    fn it_should_be_true_for_positive_i64() {
568        let left = json!(123_i64);
569        let right = json!(expect::integer().positive());
570
571        let output = expect_json_eq(&left, &right);
572        assert!(output.is_ok());
573    }
574
575    #[test]
576    fn it_should_be_true_for_positive_u64() {
577        let left = json!(123_u64);
578        let right = json!(expect::integer().positive());
579
580        let output = expect_json_eq(&left, &right);
581        assert!(output.is_ok());
582    }
583}
584
585#[cfg(test)]
586mod test_negative {
587    use crate::expect;
588    use crate::expect_json_eq;
589    use pretty_assertions::assert_eq;
590    use serde_json::json;
591
592    #[test]
593    fn it_should_be_false_for_zero() {
594        let left = json!(0);
595        let right = json!(expect::integer().negative());
596
597        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
598        assert_eq!(
599            output,
600            r#"Json expect::integer() error at root:
601    integer is not negative
602    received 0"#
603        );
604    }
605
606    #[test]
607    fn it_should_be_true_for_negative_i64() {
608        let left = json!(-1);
609        let right = json!(expect::integer().negative());
610
611        let output = expect_json_eq(&left, &right);
612        assert!(output.is_ok());
613    }
614
615    #[test]
616    fn it_should_be_false_for_positive_i64() {
617        let left = json!(123_i64);
618        let right = json!(expect::integer().negative());
619
620        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
621        assert_eq!(
622            output,
623            r#"Json expect::integer() error at root:
624    integer is not negative
625    received 123"#
626        );
627    }
628
629    #[test]
630    fn it_should_be_false_for_positive_u64() {
631        let left = json!(123_u64);
632        let right = json!(expect::integer().negative());
633
634        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
635        assert_eq!(
636            output,
637            r#"Json expect::integer() error at root:
638    integer is not negative
639    received 123"#
640        );
641    }
642}
expect_json/expect/ops/expect_integer/expect_integer.rs

expect_json/expect/ops/expect_integer/
expect_integer.rs
