Add rstest framework for unit tests (#32)

This PR introduces rstest as main unit testing framework. 
It's added as a development dependency to the project. 
maplit is added for its hashmap macro.

* Core advantages of using rstest
- can save on some boilerplate code
- easier to add new test cases
- #[once] Fixture to make an object initialise once and be 
shared between all tests

*Disadvatages of using rstest
Complex struct initialisation might not be possible in a test case. 
This can still be a no-issue because we can always write normal rust
tests for anything that can't be done using rstest.

Author: trueleo

server/Cargo.toml

@@ -56,6 +56,10 @@ ureq = "2.5.0"
 sha1_smol = { version = "1.0.0", features=["std"] }
 zip = { git = "https://github.com/zip-rs/zip" }
 
+[dev-dependencies]
+maplit = "1.0.2"
+rstest = "0.15.0"
+
 [package.metadata.parseable_ui]
 assets-url = "https://github.com/parseablehq/frontend/releases/download/v0.0.1/build.zip"
-assets-sha1 = "d9243bde7a98bdd8a19ed47cca2f12f9a5ce40ba"
+assets-sha1 = "d9243bde7a98bdd8a19ed47cca2f12f9a5ce40ba"

server/src/metadata.rs

@@ -175,3 +175,88 @@ fn parse_string(result: Result<Bytes, Error>) -> Result<String, Error> {
 
     Ok(string)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use maplit::hashmap;
+    use rstest::*;
+
+    #[rstest]
+    #[case::zero(0, 0, 0)]
+    #[case::some(1024, 512, 2048)]
+    fn update_stats(#[case] size: u64, #[case] compressed_size: u64, #[case] prev_compressed: u64) {
+        let mut stats = Stats {
+            size,
+            compressed_size,
+            prev_compressed,
+        };
+
+        stats.update(2056, 2000);
+
+        assert_eq!(
+            stats,
+            Stats {
+                size: size + 2056,
+                compressed_size: prev_compressed + 2000,
+                prev_compressed
+            }
+        )
+    }
+
+    fn clear_map() {
+        STREAM_INFO.write().unwrap().clear();
+    }
+
+    #[rstest]
+    #[case::nonempty_string("Hello world")]
+    #[case::empty_string("")]
+    fn test_parse_string(#[case] string: String) {
+        let bytes = Bytes::from(string);
+        assert!(parse_string(Ok(bytes)).is_ok())
+    }
+
+    #[test]
+    fn test_bad_parse_string() {
+        let bad: Vec<u8> = vec![195, 40];
+        let bytes = Bytes::from(bad);
+        assert!(parse_string(Ok(bytes)).is_err());
+    }
+
+    #[rstest]
+    #[case::stream_schema_alert("teststream", "schema", "alert_config")]
+    #[case::stream_only("teststream", "", "")]
+    fn test_add_stream(
+        #[case] stream_name: String,
+        #[case] schema: String,
+        #[case] alert_config: String,
+    ) {
+        clear_map();
+        STREAM_INFO
+            .add_stream(stream_name.clone(), schema.clone(), alert_config.clone())
+            .unwrap();
+
+        let left = STREAM_INFO.read().unwrap().clone();
+        let right = hashmap! {
+            stream_name => LogStreamMetadata {
+                schema: schema,
+                alert_config: alert_config,
+                ..Default::default()
+            }
+        };
+        assert_eq!(left, right);
+    }
+
+    #[rstest]
+    #[case::stream_only("teststream")]
+    fn test_delete_stream(#[case] stream_name: String) {
+        clear_map();
+        STREAM_INFO
+            .add_stream(stream_name.clone(), "".to_string(), "".to_string())
+            .unwrap();
+
+        STREAM_INFO.delete_stream(&stream_name).unwrap();
+        let map = STREAM_INFO.read().unwrap();
+        assert!(!map.contains_key(&stream_name));
+    }
+}

server/src/query.rs

@@ -111,29 +111,34 @@ impl Query {
 
 #[cfg(test)]
 mod tests {
-    use std::str::FromStr;
-
-    use serde_json::Value;
-
     use super::Query;
+    use rstest::*;
+    use serde_json::Value;
+    use std::str::FromStr;
 
-    #[test]
-    fn query_parse_prefix() {
-        let query = Value::from_str(
-            r#"{
-    "query": "SELECT * FROM stream_name",
-    "startTime": "2022-10-15T10:00:00+00:00",
-    "endTime": "2022-10-15T10:01:00+00:00"
-}"#,
-        )
-        .unwrap();
-
+    #[rstest]
+    #[case(
+        r#"{
+            "query": "SELECT * FROM stream_name",
+            "startTime": "2022-10-15T10:00:00+00:00",
+            "endTime": "2022-10-15T10:01:00+00:00"
+        }"#,
+        &["stream_name/date=2022-10-15/hour=10/minute=00/"]
+    )]
+    #[case(
+        r#"{
+            "query": "SELECT * FROM stream_name",
+            "startTime": "2022-10-15T10:00:00+00:00",
+            "endTime": "2022-10-15T10:02:00+00:00"
+        }"#,
+        &["stream_name/date=2022-10-15/hour=10/minute=00/", "stream_name/date=2022-10-15/hour=10/minute=01/"]
+    )]
+    fn query_parse_prefix(#[case] prefix: &str, #[case] right: &[&str]) {
+        let query = Value::from_str(prefix).unwrap();
         let query = Query::parse(query).unwrap();
-
         assert_eq!(&query.stream_name, "stream_name");
-        assert_eq!(
-            query.get_prefixes(),
-            vec!["stream_name/date=2022-10-15/hour=10/minute=00/".to_string()]
-        );
+        let prefixes = query.get_prefixes();
+        let left = prefixes.iter().map(String::as_str).collect::<Vec<&str>>();
+        assert_eq!(left.as_slice(), right);
     }
 }

server/src/utils.rs

@@ -281,6 +281,7 @@ impl TimePeriod {
 #[cfg(test)]
 mod tests {
     use chrono::DateTime;
+    use rstest::*;
 
     use super::TimePeriod;
 
@@ -292,125 +293,70 @@ mod tests {
         )
     }
 
-    #[test]
-    fn prefix_generation_same_minute() {
-        let time_period =
-            time_period_from_str("2022-06-11T16:30:00+00:00", "2022-06-11T16:30:59+00:00");
-
-        assert_eq!(
-            time_period.generate_prefixes("stream_name"),
-            vec!["stream_name/date=2022-06-11/hour=16/minute=30/".to_string()]
-        );
-    }
-
-    #[test]
-    fn prefix_generation_same_hour_different_minute() {
-        let time_period =
-            time_period_from_str("2022-06-11T16:57:00+00:00", "2022-06-11T16:59:00+00:00");
-
-        assert_eq!(
-            time_period.generate_prefixes("stream_name"),
-            vec![
-                "stream_name/date=2022-06-11/hour=16/minute=57/".to_string(),
-                "stream_name/date=2022-06-11/hour=16/minute=58/".to_string(),
-            ]
-        );
-    }
-
-    #[test]
-    fn prefix_generation_same_hour_with_00_to_59_minute_block() {
-        let time_period =
-            time_period_from_str("2022-06-11T16:00:00+00:00", "2022-06-11T16:59:59+00:00");
-
-        assert_eq!(
-            time_period.generate_prefixes("stream_name"),
-            vec!["stream_name/date=2022-06-11/hour=16/".to_string(),]
-        );
-    }
-
-    #[test]
-    fn prefix_generation_same_date_different_hours_coherent_minute() {
-        let time_period =
-            time_period_from_str("2022-06-11T15:00:00+00:00", "2022-06-11T17:00:00+00:00");
-
-        assert_eq!(
-            time_period.generate_prefixes("stream_name"),
-            vec![
-                "stream_name/date=2022-06-11/hour=15/".to_string(),
-                "stream_name/date=2022-06-11/hour=16/".to_string(),
-            ]
-        );
-    }
-
-    #[test]
-    fn prefix_generation_same_date_different_hours_incoherent_minutes() {
-        let time_period =
-            time_period_from_str("2022-06-11T15:59:00+00:00", "2022-06-11T16:01:00+00:00");
-
-        assert_eq!(
-            time_period.generate_prefixes("stream_name"),
-            vec![
-                "stream_name/date=2022-06-11/hour=15/minute=59/".to_string(),
-                "stream_name/date=2022-06-11/hour=16/minute=00/".to_string(),
-            ]
-        );
-    }
-
-    #[test]
-    fn prefix_generation_same_date_different_hours_whole_hours_between_incoherent_minutes() {
-        let time_period =
-            time_period_from_str("2022-06-11T15:59:00+00:00", "2022-06-11T17:01:00+00:00");
-
-        assert_eq!(
-            time_period.generate_prefixes("stream_name"),
-            vec![
-                "stream_name/date=2022-06-11/hour=15/minute=59/".to_string(),
-                "stream_name/date=2022-06-11/hour=16/".to_string(),
-                "stream_name/date=2022-06-11/hour=17/minute=00/".to_string(),
-            ]
-        );
-    }
-
-    #[test]
-    fn prefix_generation_different_date_coherent_hours_and_minutes() {
-        let time_period =
-            time_period_from_str("2022-06-11T00:00:00+00:00", "2022-06-13T00:00:00+00:00");
-
-        assert_eq!(
-            time_period.generate_prefixes("stream_name"),
-            vec![
-                "stream_name/date=2022-06-11/".to_string(),
-                "stream_name/date=2022-06-12/".to_string(),
-            ]
-        );
-    }
-
-    #[test]
-    fn prefix_generation_different_date_incoherent_hours_coherent_minutes() {
-        let time_period =
-            time_period_from_str("2022-06-11T23:00:01+00:00", "2022-06-12T01:59:59+00:00");
-
-        assert_eq!(
-            time_period.generate_prefixes("stream_name"),
-            vec![
-                "stream_name/date=2022-06-11/hour=23/".to_string(),
-                "stream_name/date=2022-06-12/hour=00/".to_string(),
-                "stream_name/date=2022-06-12/hour=01/".to_string(),
-            ]
-        );
-    }
-
-    #[test]
-    fn prefix_generation_different_date_incoherent_hours_incoherent_minutes() {
-        let time_period =
-            time_period_from_str("2022-06-11T23:59:59+00:00", "2022-06-12T00:01:00+00:00");
-
-        assert_eq!(
-            time_period.generate_prefixes("stream_name"),
-            vec![
-                "stream_name/date=2022-06-11/hour=23/minute=59/".to_string(),
-                "stream_name/date=2022-06-12/hour=00/minute=00/".to_string(),
-            ]
-        );
+    #[rstest]
+    #[case::same_minute(
+        "2022-06-11T16:30:00+00:00", "2022-06-11T16:30:59+00:00",
+        &["stream_name/date=2022-06-11/hour=16/minute=30/"]
+    )]
+    #[case::same_hour_different_minute(
+        "2022-06-11T16:57:00+00:00", "2022-06-11T16:59:00+00:00",
+        &[
+            "stream_name/date=2022-06-11/hour=16/minute=57/",
+            "stream_name/date=2022-06-11/hour=16/minute=58/"
+        ]
+    )]
+    #[case::same_hour_with_00_to_59_minute_block(
+        "2022-06-11T16:00:00+00:00", "2022-06-11T16:59:59+00:00",   
+        &["stream_name/date=2022-06-11/hour=16/"]
+    )]
+    #[case::same_date_different_hours_coherent_minute(
+        "2022-06-11T15:00:00+00:00", "2022-06-11T17:00:00+00:00",
+       &[
+            "stream_name/date=2022-06-11/hour=15/",
+            "stream_name/date=2022-06-11/hour=16/"
+        ]
+    )]
+    #[case::same_date_different_hours_incoherent_minutes(
+        "2022-06-11T15:59:00+00:00", "2022-06-11T16:01:00+00:00", 
+        &[
+            "stream_name/date=2022-06-11/hour=15/minute=59/",
+            "stream_name/date=2022-06-11/hour=16/minute=00/"
+        ]
+    )]
+    #[case::same_date_different_hours_whole_hours_between_incoherent_minutes(
+        "2022-06-11T15:59:00+00:00", "2022-06-11T17:01:00+00:00", 
+        &[
+            "stream_name/date=2022-06-11/hour=15/minute=59/",
+            "stream_name/date=2022-06-11/hour=16/",
+            "stream_name/date=2022-06-11/hour=17/minute=00/"
+        ]
+    )]
+    #[case::different_date_coherent_hours_and_minutes(
+        "2022-06-11T00:00:00+00:00", "2022-06-13T00:00:00+00:00", 
+        &[
+            "stream_name/date=2022-06-11/",
+            "stream_name/date=2022-06-12/"
+        ]
+    )]
+    #[case::different_date_incoherent_hours_coherent_minutes(
+        "2022-06-11T23:00:01+00:00", "2022-06-12T01:59:59+00:00", 
+        &[
+            "stream_name/date=2022-06-11/hour=23/",
+            "stream_name/date=2022-06-12/hour=00/",
+            "stream_name/date=2022-06-12/hour=01/"
+        ]
+    )]
+    #[case::different_date_incoherent_hours_incoherent_minutes(
+        "2022-06-11T23:59:59+00:00", "2022-06-12T00:01:00+00:00", 
+        &[
+            "stream_name/date=2022-06-11/hour=23/minute=59/",
+            "stream_name/date=2022-06-12/hour=00/minute=00/"
+        ]
+    )]
+    fn prefix_generation(#[case] start: &str, #[case] end: &str, #[case] right: &[&str]) {
+        let time_period = time_period_from_str(start, end);
+        let prefixes = time_period.generate_prefixes("stream_name");
+        let left = prefixes.iter().map(String::as_str).collect::<Vec<&str>>();
+        assert_eq!(left.as_slice(), right);
     }
 }