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