Remove should_panic unit tests #307 (#314)

Azure · Jun 24, 2021 · 29d904b · 29d904b
1 parent 718bbed
commit 29d904b
Show file tree

Hide file tree

Showing 7 changed files with 80 additions and 42 deletions.
diff --git a/sdk/core/src/errors.rs b/sdk/core/src/errors.rs
@@ -1,6 +1,7 @@
 use http::StatusCode;
 #[cfg(feature = "enable_hyper")]
 use hyper::{self, body, Body};
+use std::cmp::PartialEq;
 
 #[non_exhaustive]
 #[derive(Debug, thiserror::Error)]
@@ -44,7 +45,7 @@ type HttpClientError = hyper::Error;
 type HttpClientError = reqwest::Error;
 
 #[non_exhaustive]
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, PartialEq, thiserror::Error)]
 pub enum ParsingError {
     #[error("unknown variant of {item} found: \"{variant}\"")]
     UnknownVariant { item: &'static str, variant: String },
@@ -167,7 +168,7 @@ impl HttpError {
         }
     }
 }
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, PartialEq, thiserror::Error)]
 pub enum Not512ByteAlignedError {
     #[error("start range not 512-byte aligned: {0}")]
     StartRange(u64),
@@ -186,7 +187,7 @@ pub enum PermissionError {
     },
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, PartialEq, thiserror::Error)]
 pub enum Parse512AlignedError {
     #[error("split not found")]
     SplitNotFound,

diff --git a/sdk/core/src/macros.rs b/sdk/core/src/macros.rs
@@ -171,6 +171,7 @@ macro_rules! response_from_headers {
 
 #[cfg(test)]
 mod test {
+    use crate::ParsingError;
     create_enum!(Colors, (Black, "Black"), (White, "White"), (Red, "Red"));
     create_enum!(ColorsMonochrome, (Black, "Black"), (White, "White"));
 
@@ -206,9 +207,15 @@ mod test {
     }
 
     #[test]
-    #[should_panic(expected = "UnknownVariant { item: \"ColorsMonochrome\", variant: \"Red\" }")]
     fn test_color_parse_err_1() {
-        "Red".parse::<ColorsMonochrome>().unwrap();
+        let err = "Red".parse::<ColorsMonochrome>().unwrap_err();
+        assert_eq!(
+            err,
+            ParsingError::UnknownVariant {
+                item: "ColorsMonochrome",
+                variant: "Red".to_string()
+            }
+        );
     }
 
     #[test]

diff --git a/sdk/core/src/request_options/ba512_range.rs b/sdk/core/src/request_options/ba512_range.rs
@@ -92,6 +92,7 @@ impl fmt::Display for BA512Range {
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::Not512ByteAlignedError::{EndRange, StartRange};
 
     #[test]
     fn test_512range_parse() {
@@ -102,27 +103,33 @@ mod test {
     }
 
     #[test]
-    #[should_panic(expected = "ParseIntError(ParseIntError { kind: InvalidDigit })")]
     fn test_512range_parse_panic_1() {
-        "abba/2000".parse::<BA512Range>().unwrap();
+        let err = "abba/2000".parse::<BA512Range>().unwrap_err();
+        assert!(matches!(err, Parse512AlignedError::ParseIntError(_)));
     }
 
     #[test]
-    #[should_panic(expected = "SplitNotFound")]
     fn test_512range_parse_panic_2() {
-        "1000-2000".parse::<BA512Range>().unwrap();
+        let err = "1000-2000".parse::<BA512Range>().unwrap_err();
+        assert_eq!(err, Parse512AlignedError::SplitNotFound);
     }
 
     #[test]
-    #[should_panic(expected = "Not512ByteAlignedError(StartRange(7))")]
     fn test_512range_invalid_start_range() {
-        "7/511".parse::<BA512Range>().unwrap();
+        let err = "7/511".parse::<BA512Range>().unwrap_err();
+        assert_eq!(
+            err,
+            Parse512AlignedError::Not512ByteAlignedError(StartRange(7))
+        );
     }
 
     #[test]
-    #[should_panic(expected = "Not512ByteAlignedError(EndRange(100))")]
     fn test_512range_invalid_end_range() {
-        "0/100".parse::<BA512Range>().unwrap();
+        let err = "0/100".parse::<BA512Range>().unwrap_err();
+        assert_eq!(
+            err,
+            Parse512AlignedError::Not512ByteAlignedError(EndRange(100))
+        );
     }
 
     #[test]

diff --git a/sdk/core/src/request_options/content_range.rs b/sdk/core/src/request_options/content_range.rs
@@ -107,27 +107,42 @@ mod test {
     }
 
     #[test]
-    #[should_panic(
-        expected = "TokenNotFound { item: \"ContentRange\", token: \"bytes \", full: \"something else\" }"
-    )]
     fn test_parse_no_starting_token() {
-        "something else".parse::<ContentRange>().unwrap();
+        let err = "something else".parse::<ContentRange>().unwrap_err();
+        assert_eq!(
+            err,
+            ParsingError::TokenNotFound {
+                item: "ContentRange",
+                token: "bytes ".to_string(),
+                full: "something else".to_string()
+            }
+        );
     }
 
     #[test]
-    #[should_panic(
-        expected = "TokenNotFound { item: \"ContentRange\", token: \"-\", full: \"bytes 100\""
-    )]
     fn test_parse_no_dash() {
-        "bytes 100".parse::<ContentRange>().unwrap();
+        let err = "bytes 100".parse::<ContentRange>().unwrap_err();
+        assert_eq!(
+            err,
+            ParsingError::TokenNotFound {
+                item: "ContentRange",
+                token: "-".to_string(),
+                full: "bytes 100".to_string()
+            }
+        );
     }
 
     #[test]
-    #[should_panic(
-        expected = "TokenNotFound { item: \"ContentRange\", token: \"/\", full: \"bytes 100-500\""
-    )]
     fn test_parse_no_slash() {
-        "bytes 100-500".parse::<ContentRange>().unwrap();
+        let err = "bytes 100-500".parse::<ContentRange>().unwrap_err();
+        assert_eq!(
+            err,
+            ParsingError::TokenNotFound {
+                item: "ContentRange",
+                token: "/".to_string(),
+                full: "bytes 100-500".to_string()
+            }
+        );
     }
 
     #[test]

diff --git a/sdk/core/src/request_options/range.rs b/sdk/core/src/request_options/range.rs
@@ -115,15 +115,22 @@ mod test {
     }
 
     #[test]
-    #[should_panic(expected = "ParseIntError(ParseIntError { kind: InvalidDigit })")]
     fn test_range_parse_panic_1() {
-        "abba/2000".parse::<Range>().unwrap();
+        let err = "abba/2000".parse::<Range>().unwrap_err();
+        assert!(matches!(err, ParsingError::ParseIntError(_)));
     }
 
     #[test]
-    #[should_panic(expected = "TokenNotFound")]
     fn test_range_parse_panic_2() {
-        "1000-2000".parse::<Range>().unwrap();
+        let err = "1000-2000".parse::<Range>().unwrap_err();
+        assert_eq!(
+            err,
+            ParsingError::TokenNotFound {
+                item: "Range",
+                token: "/".to_string(),
+                full: "1000-2000".to_string()
+            }
+        );
     }
 
     #[test]

diff --git a/sdk/storage/src/core/errors.rs b/sdk/storage/src/core/errors.rs
@@ -1,3 +1,4 @@
+use std::cmp::PartialEq;
 #[non_exhaustive]
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
@@ -69,7 +70,7 @@ pub enum Error {
 }
 
 #[non_exhaustive]
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, PartialEq, thiserror::Error)]
 pub enum AzurePathParseError {
     #[error("path separator not found")]
     PathSeparatorNotFoundError,

diff --git a/sdk/storage/src/core/into_azure_path.rs b/sdk/storage/src/core/into_azure_path.rs
@@ -72,38 +72,38 @@ mod test {
     }
 
     #[test]
-    #[should_panic(expected = "PathSeparatorNotFoundError")]
     fn no_slash() {
         let path = "containerblob";
         let p = &path;
-        assert!(p.container_name().unwrap() == "container");
-        assert!(path.blob_name().unwrap() == "blob");
+        let err = AzurePathParseError::PathSeparatorNotFoundError;
+        assert_eq!(p.container_name().unwrap_err(), err);
+        assert_eq!(path.blob_name().unwrap_err(), err);
     }
 
     #[test]
-    #[should_panic(expected = "MultiplePathSeparatorsFoundError")]
     fn three_slashes() {
         let path = "container/blob/extra";
         let p = &path;
-        assert!(p.container_name().unwrap() == "container");
-        assert!(path.blob_name().unwrap() == "blob");
+        let err = AzurePathParseError::MultiplePathSeparatorsFoundError;
+        assert_eq!(p.container_name().unwrap_err(), err);
+        assert_eq!(path.blob_name().unwrap_err(), err);
     }
 
     #[test]
-    #[should_panic(expected = "MissingContainerError")]
     fn missing_container() {
         let path = "/blob";
         let p = &path;
-        assert!(p.container_name().unwrap() == "container");
-        assert!(path.blob_name().unwrap() == "blob");
+        let err = AzurePathParseError::MissingContainerError;
+        assert_eq!(p.container_name().unwrap_err(), err);
+        assert_eq!(path.blob_name().unwrap_err(), err);
     }
 
     #[test]
-    #[should_panic(expected = "MissingBlobError")]
     fn missing_blob() {
         let path = "container/";
         let p = &path;
-        assert!(p.container_name().unwrap() == "container");
-        assert!(path.blob_name().unwrap() == "blob");
+        let err = AzurePathParseError::MissingBlobError;
+        assert_eq!(p.container_name().unwrap_err(), err);
+        assert_eq!(path.blob_name().unwrap_err(), err);
     }
 }