test: add tests to improve code coverage

Author: brianheineman

postgresql_archive/src/error.rs

@@ -70,3 +70,64 @@ impl From<anyhow::Error> for ArchiveError {
         ArchiveError::Unexpected(error.to_string())
     }
 }
+
+/// These are relatively low value tests; they are here to reduce the coverage gap and
+/// ensure that the error conversions are working as expected.
+#[cfg(test)]
+mod test {
+    use super::*;
+    use std::path::PathBuf;
+    use std::str::FromStr;
+
+    #[test]
+    fn test_from_regex_error() {
+        let regex_error = regex::Error::Syntax("test".to_string());
+        let error = ArchiveError::from(regex_error);
+        assert_eq!(error.to_string(), "test");
+    }
+
+    #[tokio::test]
+    async fn test_from_reqwest_error() {
+        let result = reqwest::get("https://a.com").await;
+        assert!(result.is_err());
+        if let Err(error) = result {
+            let error = ArchiveError::from(error);
+            assert!(error.to_string().contains("https://a.com"));
+        }
+    }
+
+    #[test]
+    fn test_from_io_error() {
+        let io_error = std::io::Error::new(std::io::ErrorKind::NotFound, "test");
+        let error = ArchiveError::from(io_error);
+        assert_eq!(error.to_string(), "test");
+    }
+
+    #[test]
+    fn test_from_parse_int_error() {
+        let result = u64::from_str("test");
+        assert!(result.is_err());
+        if let Err(error) = result {
+            let error = ArchiveError::from(error);
+            assert_eq!(error.to_string(), "invalid digit found in string");
+        }
+    }
+
+    #[test]
+    fn test_from_strip_prefix_error() {
+        let path = PathBuf::from("test");
+        let result = path.strip_prefix("foo");
+        assert!(result.is_err());
+        if let Err(error) = result {
+            let error = ArchiveError::from(error);
+            assert_eq!(error.to_string(), "prefix not found");
+        }
+    }
+
+    #[test]
+    fn test_from_anyhow_error() {
+        let anyhow_error = anyhow::Error::msg("test");
+        let error = ArchiveError::from(anyhow_error);
+        assert_eq!(error.to_string(), "test");
+    }
+}

postgresql_embedded/src/blocking/mod.rs

@@ -82,3 +82,16 @@ impl PostgreSQL {
             .block_on(async move { self.inner.drop_database(database_name).await })
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_postgresql() {
+        let version = Version::new(16, Some(2), Some(0));
+        let postgresql = PostgreSQL::new(version, Settings::default());
+        assert!(vec!(Status::Stopped, Status::Installed).contains(&postgresql.status()));
+        assert_eq!(postgresql.version(), &version);
+    }
+}

postgresql_embedded/src/error.rs

@@ -74,3 +74,54 @@ impl From<tokio::time::error::Elapsed> for EmbeddedError {
         EmbeddedError::TimeoutError(error.into())
     }
 }
+
+/// These are relatively low value tests; they are here to reduce the coverage gap and
+/// ensure that the error conversions are working as expected.
+#[cfg(test)]
+mod test {
+    use super::*;
+    use std::time::Duration;
+    use tokio::time::timeout;
+
+    #[test]
+    fn test_from_archive_error() {
+        let archive_error = ArchiveError::ReleaseNotFound("test".to_string());
+        let error = EmbeddedError::from(archive_error);
+        assert_eq!(error.to_string(), "release not found for version [test]");
+    }
+
+    #[test]
+    fn test_from_io_error() {
+        let io_error = std::io::Error::new(std::io::ErrorKind::Other, "test");
+        let error = EmbeddedError::from(io_error);
+        assert_eq!(error.to_string(), "test");
+    }
+
+    #[test]
+    fn test_from_utf8_error() {
+        let invalid_utf8: Vec<u8> = vec![0, 159, 146, 150];
+        let result = String::from_utf8(invalid_utf8);
+        assert!(result.is_err());
+        if let Err(error) = result {
+            let error = EmbeddedError::from(error);
+            assert_eq!(
+                error.to_string(),
+                "invalid utf-8 sequence of 1 bytes from index 1"
+            );
+        }
+    }
+
+    #[cfg(feature = "tokio")]
+    #[tokio::test]
+    async fn test_from_elapsed_error() {
+        let result = timeout(Duration::from_nanos(1), async {
+            tokio::time::sleep(Duration::from_millis(1)).await;
+        })
+        .await;
+        assert!(result.is_err());
+        if let Err(elapsed_error) = result {
+            let error = EmbeddedError::from(elapsed_error);
+            assert_eq!(error.to_string(), "deadline has elapsed");
+        }
+    }
+}

postgresql_embedded/src/settings.rs

@@ -7,7 +7,7 @@ use std::path::PathBuf;
 use std::time::Duration;
 
 /// Database settings
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, PartialOrd)]
 pub struct Settings {
     /// PostgreSQL installation directory
     pub installation_dir: PathBuf,