test coverage

pydantic · Dec 4, 2023 · 769d40e · 769d40e
1 parent 7280838
commit 769d40e
Show file tree

Hide file tree

Showing 2 changed files with 65 additions and 28 deletions.
diff --git a/src/jiter.rs b/src/jiter.rs
@@ -3,6 +3,7 @@ use crate::number_decoder::{NumberAny, NumberFloat, NumberInt, NumberRange};
 use crate::parse::{Parser, Peek};
 use crate::string_decoder::{StringDecoder, StringDecoderRange, Tape};
 use crate::value::{take_value, JsonValue};
+use crate::JsonError;
 
 pub type JiterResult<T> = Result<T, JiterError>;
 
@@ -112,13 +113,7 @@ impl<'j> Jiter<'j> {
     pub fn known_number(&mut self, peek: Peek) -> JiterResult<NumberAny> {
         self.parser
             .consume_number::<NumberAny>(peek.into_inner(), self.allow_inf_nan)
-            .map_err(|e| {
-                if !peek.is_num() {
-                    self.wrong_type(JsonType::Int, peek)
-                } else {
-                    e.into()
-                }
-            })
+            .map_err(|e| self.maybe_number_error(e, JsonType::Int, peek))
     }
 
     /// Assuming the next value is an integer, consume it. Error if it is not an integer, or is invalid JSON.
@@ -131,13 +126,7 @@ impl<'j> Jiter<'j> {
     pub fn known_int(&mut self, peek: Peek) -> JiterResult<NumberInt> {
         self.parser
             .consume_number::<NumberInt>(peek.into_inner(), self.allow_inf_nan)
-            .map_err(|e| {
-                if !peek.is_num() {
-                    self.wrong_type(JsonType::Int, peek)
-                } else {
-                    e.into()
-                }
-            })
+            .map_err(|e| self.maybe_number_error(e, JsonType::Int, peek))
     }
 
     /// Assuming the next value is a float, consume it. Error if it is not a float, or is invalid JSON.
@@ -150,13 +139,7 @@ impl<'j> Jiter<'j> {
     pub fn known_float(&mut self, peek: Peek) -> JiterResult<f64> {
         self.parser
             .consume_number::<NumberFloat>(peek.into_inner(), self.allow_inf_nan)
-            .map_err(|e| {
-                if !peek.is_num() {
-                    self.wrong_type(JsonType::Float, peek)
-                } else {
-                    e.into()
-                }
-            })
+            .map_err(|e| self.maybe_number_error(e, JsonType::Float, peek))
     }
 
     /// Assuming the next value is a number, consume it and return bytes from the original JSON data.
@@ -172,13 +155,7 @@ impl<'j> Jiter<'j> {
             .consume_number::<NumberRange>(peek.into_inner(), self.allow_inf_nan)
         {
             Ok(range) => Ok(&self.data[range]),
-            Err(e) => {
-                if !peek.is_num() {
-                    Err(self.wrong_type(JsonType::Float, peek))
-                } else {
-                    Err(e.into())
-                }
-            }
+            Err(e) => Err(self.maybe_number_error(e, JsonType::Float, peek)),
         }
     }
 
@@ -327,4 +304,12 @@ impl<'j> Jiter<'j> {
         };
         JiterError::wrong_type(expected, actual, self.parser.index)
     }
+
+    fn maybe_number_error(&self, e: JsonError, expected: JsonType, peek: Peek) -> JiterError {
+        if peek.is_num() {
+            e.into()
+        } else {
+            self.wrong_type(expected, peek)
+        }
+    }
 }
diff --git a/tests/main.rs b/tests/main.rs
@@ -934,3 +934,55 @@ fn jiter_clone() {
     jiter1.finish().unwrap();
     jiter2.finish().unwrap();
 }
+
+#[test]
+fn jiter_invalid_value() {
+    let mut jiter = Jiter::new(b" bar", false);
+    let e = jiter.next_value().unwrap_err();
+    assert_eq!(
+        e.error_type,
+        JiterErrorType::JsonError(JsonErrorType::ExpectedSomeValue)
+    );
+    assert_eq!(e.index, 1);
+    assert_eq!(jiter.error_position(e.index), LinePosition::new(1, 2));
+}
+
+#[test]
+fn jiter_invalid_numbers() {
+    let mut jiter = Jiter::new(b" -a", false);
+    let peek = jiter.peek().unwrap();
+    let e = jiter.known_int(peek).unwrap_err();
+    assert_eq!(e.error_type, JiterErrorType::JsonError(JsonErrorType::InvalidNumber));
+    let e = jiter.known_float(peek).unwrap_err();
+    assert_eq!(e.error_type, JiterErrorType::JsonError(JsonErrorType::InvalidNumber));
+    let e = jiter.known_number(peek).unwrap_err();
+    assert_eq!(e.error_type, JiterErrorType::JsonError(JsonErrorType::InvalidNumber));
+    let e = jiter.next_number_bytes().unwrap_err();
+    assert_eq!(e.error_type, JiterErrorType::JsonError(JsonErrorType::InvalidNumber));
+}
+
+#[test]
+fn jiter_invalid_numbers_expected_some_value() {
+    let mut jiter = Jiter::new(b" bar", false);
+    let peek = jiter.peek().unwrap();
+    let e = jiter.known_int(peek).unwrap_err();
+    assert_eq!(
+        e.error_type,
+        JiterErrorType::JsonError(JsonErrorType::ExpectedSomeValue)
+    );
+    let e = jiter.known_float(peek).unwrap_err();
+    assert_eq!(
+        e.error_type,
+        JiterErrorType::JsonError(JsonErrorType::ExpectedSomeValue)
+    );
+    let e = jiter.known_number(peek).unwrap_err();
+    assert_eq!(
+        e.error_type,
+        JiterErrorType::JsonError(JsonErrorType::ExpectedSomeValue)
+    );
+    let e = jiter.next_number_bytes().unwrap_err();
+    assert_eq!(
+        e.error_type,
+        JiterErrorType::JsonError(JsonErrorType::ExpectedSomeValue)
+    );
+}