complete unit tests (RedisJSON#587)

gkorland · web-flow · commit ed4c752e3d64 · 2021-12-27T13:23:41.000+02:00
* complete unit tests

* add tests for formatter

* format code

* run all tests
diff --git a/.circleci/config.yml b/.circleci/config.yml
@@ -153,7 +153,7 @@ commands:
           name: Run all tests
           command: |
             bash -l -c "python3 -m RLTest --version"
-            bash -l -c "make pytest"
+            bash -l -c "make test"
           timeout: 30m
           no_output_timeout: 30m
       - save_cache:
diff --git a/src/error.rs b/src/error.rs
@@ -75,8 +75,8 @@ impl From<Error> for redis_module::RedisError {
 
 #[cfg(test)]
 mod tests {
-    // Note this useful idiom: importing names from outer (for mod tests) scope.
     use super::*;
+    use serde_json::{Result, Value};
 
     #[test]
     fn test_from_string() {
@@ -104,6 +104,12 @@ mod tests {
 
     #[test]
     fn test_from_redis_error() {
+        let err: Error = RedisError::short_read().into();
+        assert_eq!(err.msg, "ERR ERR short read or OOM loading DB");
+    }
+
+    #[test]
+    fn test_from_error() {
         let err: Error = redis_module::error::Error::generic("error from Generic").into();
         assert_eq!(err.msg, "Store error: error from Generic");
 
@@ -118,11 +124,12 @@ mod tests {
         assert_eq!(err.msg, "invalid digit found in string");
     }
 
-    // #[test]
-    // fn test_from_serde_json_error() {
-    //     let err : Error = serde_json::Error "error from str".into();
-    //     assert_eq!(err.msg, "error from str");
-    // }
+    #[test]
+    fn test_from_serde_json_error() {
+        let res: Result<Value> = serde_json::from_str("{");
+        let err: Error = res.unwrap_err().into();
+        assert_eq!(err.msg, "EOF while parsing an object at line 1 column 1");
+    }
 
     #[test]
     fn test_from_jsonpath_error() {
@@ -135,4 +142,13 @@ mod tests {
         let err: Error = "error from str".into();
         assert_eq!(err.msg, "error from str");
     }
+
+    #[test]
+    fn test_to_redis_error() {
+        let err: redis_module::RedisError = Error {
+            msg: "to RedisError".to_string(),
+        }
+        .into();
+        assert_eq!(err.to_string(), "to RedisError".to_string());
+    }
 }
diff --git a/src/formatter.rs b/src/formatter.rs
@@ -53,12 +53,12 @@ impl<'a> RedisJsonFormatter<'a> {
         W: io::Write,
     {
         // Write new line if defined
-        if let Some(n) = self.newline.as_ref() {
+        if let Some(n) = self.newline {
             wr.write_all(n.as_bytes())?;
         }
 
         // Ident the next line if defined
-        if let Some(s) = self.indent.as_ref() {
+        if let Some(s) = self.indent {
             let bytes = s.as_bytes();
             for _ in 0..self.current_indent {
                 wr.write_all(bytes)?;
@@ -147,7 +147,7 @@ impl Formatter for RedisJsonFormatter<'_> {
         W: io::Write,
     {
         writer.write_all(b":")?;
-        if let Some(s) = self.space.as_ref() {
+        if let Some(s) = self.space {
             writer.write_all(s.as_bytes())
         } else {
             Ok(())
@@ -162,3 +162,236 @@ impl Formatter for RedisJsonFormatter<'_> {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_default_formatter() {
+        let mut formatter = RedisJsonFormatter::new(None, None, None);
+        let mut writer = vec![];
+
+        assert!(matches!(formatter.begin_array(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[");
+
+        assert!(matches!(
+            formatter.begin_array_value(&mut writer, true),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[");
+
+        assert!(matches!(formatter.begin_object(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[{");
+
+        assert!(matches!(
+            formatter.begin_object_key(&mut writer, true),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[{");
+
+        assert!(matches!(
+            formatter.begin_object_key(&mut writer, false),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[{,");
+
+        assert!(matches!(formatter.begin_object_value(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[{,:");
+
+        assert!(matches!(formatter.end_object_value(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[{,:");
+
+        assert!(matches!(formatter.end_object(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[{,:}");
+
+        assert!(matches!(
+            formatter.begin_array_value(&mut writer, true),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[{,:}");
+
+        assert!(matches!(formatter.end_array_value(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[{,:}");
+
+        assert!(matches!(
+            formatter.begin_array_value(&mut writer, false),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[{,:},");
+
+        assert!(matches!(formatter.end_array(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[{,:},]");
+    }
+
+    #[test]
+    fn test_ident_formatter() {
+        let mut formatter = RedisJsonFormatter::new(Some("_"), None, None);
+        let mut writer = vec![];
+
+        assert!(matches!(formatter.begin_array(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[");
+
+        assert!(matches!(
+            formatter.begin_array_value(&mut writer, true),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[_");
+
+        assert!(matches!(formatter.begin_object(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[_{");
+
+        assert!(matches!(
+            formatter.begin_object_key(&mut writer, true),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[_{__");
+
+        assert!(matches!(
+            formatter.begin_object_key(&mut writer, false),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[_{__,__");
+
+        assert!(matches!(formatter.begin_object_value(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[_{__,__:");
+
+        assert!(matches!(formatter.end_object_value(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[_{__,__:");
+
+        assert!(matches!(formatter.end_object(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[_{__,__:_}");
+
+        assert!(matches!(
+            formatter.begin_array_value(&mut writer, true),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[_{__,__:_}_");
+
+        assert!(matches!(formatter.end_array_value(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[_{__,__:_}_");
+
+        assert!(matches!(
+            formatter.begin_array_value(&mut writer, false),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[_{__,__:_}_,_");
+
+        assert!(matches!(formatter.end_array(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[_{__,__:_}_,_]");
+    }
+
+    #[test]
+    fn test_space_formatter() {
+        let mut formatter = RedisJsonFormatter::new(None, Some("s"), None);
+        let mut writer = vec![];
+
+        assert!(matches!(formatter.begin_array(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[");
+
+        assert!(matches!(
+            formatter.begin_array_value(&mut writer, true),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[");
+
+        assert!(matches!(formatter.begin_object(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[{");
+
+        assert!(matches!(
+            formatter.begin_object_key(&mut writer, true),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[{");
+
+        assert!(matches!(
+            formatter.begin_object_key(&mut writer, false),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[{,");
+
+        assert!(matches!(formatter.begin_object_value(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[{,:s");
+
+        assert!(matches!(formatter.end_object_value(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[{,:s");
+
+        assert!(matches!(formatter.end_object(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[{,:s}");
+
+        assert!(matches!(
+            formatter.begin_array_value(&mut writer, true),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[{,:s}");
+
+        assert!(matches!(formatter.end_array_value(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[{,:s}");
+
+        assert!(matches!(
+            formatter.begin_array_value(&mut writer, false),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[{,:s},");
+
+        assert!(matches!(formatter.end_array(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[{,:s},]");
+    }
+
+    #[test]
+    fn test_new_line_formatter() {
+        let mut formatter = RedisJsonFormatter::new(None, None, Some("n"));
+        let mut writer = vec![];
+
+        assert!(matches!(formatter.begin_array(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[");
+
+        assert!(matches!(
+            formatter.begin_array_value(&mut writer, true),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[n");
+
+        assert!(matches!(formatter.begin_object(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[n{");
+
+        assert!(matches!(
+            formatter.begin_object_key(&mut writer, true),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[n{n");
+
+        assert!(matches!(
+            formatter.begin_object_key(&mut writer, false),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[n{n,n");
+
+        assert!(matches!(formatter.begin_object_value(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[n{n,n:");
+
+        assert!(matches!(formatter.end_object_value(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[n{n,n:");
+
+        assert!(matches!(formatter.end_object(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[n{n,n:n}");
+
+        assert!(matches!(
+            formatter.begin_array_value(&mut writer, true),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[n{n,n:n}n");
+
+        assert!(matches!(formatter.end_array_value(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[n{n,n:n}n");
+
+        assert!(matches!(
+            formatter.begin_array_value(&mut writer, false),
+            Ok(())
+        ));
+        assert_eq!(&writer[0..], b"[n{n,n:n}n,n");
+
+        assert!(matches!(formatter.end_array(&mut writer), Ok(())));
+        assert_eq!(&writer[0..], b"[n{n,n:n}n,nn]");
+    }
+}
