Merge pull request #16 from theseus-rs/improve-test-coverage

test: improve lifecycle test coverage

Author: brianheineman

postgresql_embedded/src/error.rs

@@ -9,9 +9,6 @@ pub enum Error {
     /// Error when PostgreSQL archive operations fail
     #[error(transparent)]
     ArchiveError(postgresql_archive::Error),
-    /// Error when the archive is not found for a specific version
-    #[error("Archive not found for version [{0}]")]
-    ArchiveNotFound(String),
     /// Error when a command fails
     #[error("Command error: stdout={stdout}; stderr={stderr}")]
     CommandError { stdout: String, stderr: String },
@@ -108,7 +105,7 @@ mod test {
     #[tokio::test]
     async fn test_from_elapsed_error() {
         let result = tokio::time::timeout(std::time::Duration::from_nanos(1), async {
-            tokio::time::sleep(std::time::Duration::from_millis(1)).await;
+            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
         })
         .await;
         assert!(result.is_err());

postgresql_embedded/src/postgresql.rs

@@ -3,9 +3,7 @@ use crate::command::pg_ctl::Mode::{Start, Stop};
 use crate::command::pg_ctl::PgCtlBuilder;
 use crate::command::pg_ctl::ShutdownMode::Fast;
 use crate::command::traits::{CommandBuilder, CommandExecutor};
-use crate::error::Error::{
-    ArchiveNotFound, DatabaseInitializationError, DatabaseStartError, DatabaseStopError,
-};
+use crate::error::Error::{DatabaseInitializationError, DatabaseStartError, DatabaseStopError};
 use crate::error::Result;
 use crate::settings::Settings;
 use bytes::Bytes;
@@ -94,7 +92,7 @@ impl PostgreSQL {
         postgresql
     }
 
-    /// Get the default version used by if not otherwise specified
+    /// Get the default version used if not otherwise specified
     pub fn default_version() -> Version {
         if cfg!(feature = "bundled") {
             *ARCHIVE_VERSION
@@ -168,19 +166,8 @@ impl PostgreSQL {
     /// already exists, the archive will not be extracted. If the archive is not found, an error will be
     /// returned.
     async fn install(&mut self) -> Result<()> {
-        let mut archive_bytes: Option<Bytes> = None;
-
         debug!("Starting installation process for version {}", self.version);
 
-        #[cfg(feature = "bundled")]
-        // If the requested version is the same as the version of the bundled archive, use the bundled
-        // archive. This avoids downloading the archive in environments where internet access is
-        // restricted or undesirable.
-        if ARCHIVE_VERSION.deref() == &self.version {
-            debug!("Using bundled installation archive");
-            archive_bytes = Some(Bytes::copy_from_slice(ARCHIVE));
-        }
-
         // If the minor and release version are not set, determine the latest version and update the
         // version and installation directory accordingly. This is an optimization to avoid downloading
         // the archive if the latest version is already installed.
@@ -191,35 +178,33 @@ impl PostgreSQL {
                 .settings
                 .installation_dir
                 .join(self.version.to_string());
-
-            if self.settings.installation_dir.exists() {
-                debug!("Installation directory already exists");
-                self.update_status();
-                return Ok(());
-            }
         }
 
-        if archive_bytes.is_none() {
-            let (version, bytes) = get_archive(&self.version).await?;
-            self.version = version;
-            archive_bytes = Some(bytes);
+        if self.settings.installation_dir.exists() {
+            debug!("Installation directory already exists");
+            self.update_status();
+            return Ok(());
         }
 
-        if !self.settings.installation_dir.exists() {
-            self.status = Status::Installing;
-            create_dir_all(&self.settings.installation_dir)?;
-
-            match archive_bytes {
-                Some(bytes) => {
-                    extract(&bytes, &self.settings.installation_dir).await?;
-                    self.status = Status::Installed;
-                }
-                None => {
-                    self.update_status();
-                    return Err(ArchiveNotFound(self.version.to_string()));
-                }
-            }
-        }
+        #[cfg(feature = "bundled")]
+        // If the requested version is the same as the version of the bundled archive, use the bundled
+        // archive. This avoids downloading the archive in environments where internet access is
+        // restricted or undesirable.
+        let (version, bytes) = if ARCHIVE_VERSION.deref() == &self.version {
+            debug!("Using bundled installation archive");
+            (self.version, Bytes::copy_from_slice(ARCHIVE))
+        } else {
+            get_archive(&self.version).await?
+        };
+
+        #[cfg(not(feature = "bundled"))]
+        let (version, bytes) = { get_archive(&self.version).await? };
+
+        self.version = version;
+        self.status = Status::Installing;
+        create_dir_all(&self.settings.installation_dir)?;
+        extract(&bytes, &self.settings.installation_dir).await?;
+        self.status = Status::Installed;
 
         debug!(
             "Installed PostgreSQL version {} to {}",

postgresql_embedded/tests/blocking.rs

@@ -9,6 +9,11 @@ use test_log::test;
 #[test]
 fn test_lifecycle() -> Result<()> {
     let mut postgresql = PostgreSQL::default();
+    let settings = postgresql.settings();
+
+    // Verify that an ephemeral instance is created by default
+    assert_eq!(0, settings.port);
+    assert!(settings.temporary);
 
     let initial_statuses = [Status::NotInstalled, Status::Installed, Status::Stopped];
     assert!(initial_statuses.contains(&postgresql.status()));
@@ -20,6 +25,7 @@ fn test_lifecycle() -> Result<()> {
     assert_eq!(Status::Started, postgresql.status());
 
     let database_name = "test";
+    assert!(!postgresql.database_exists(database_name)?);
     postgresql.create_database(database_name)?;
     assert!(postgresql.database_exists(database_name)?);
     postgresql.drop_database(database_name)?;

postgresql_embedded/tests/postgresql.rs

@@ -6,6 +6,11 @@ use test_log::test;
 
 async fn lifecycle() -> Result<()> {
     let mut postgresql = PostgreSQL::default();
+    let settings = postgresql.settings();
+
+    // Verify that an ephemeral instance is created by default
+    assert_eq!(0, settings.port);
+    assert!(settings.temporary);
 
     let initial_statuses = [Status::NotInstalled, Status::Installed, Status::Stopped];
     assert!(initial_statuses.contains(&postgresql.status()));
@@ -17,6 +22,7 @@ async fn lifecycle() -> Result<()> {
     assert_eq!(Status::Started, postgresql.status());
 
     let database_name = "test";
+    assert!(!postgresql.database_exists(database_name).await?);
     postgresql.create_database(database_name).await?;
     assert!(postgresql.database_exists(database_name).await?);
     postgresql.drop_database(database_name).await?;