feat: add Container*::is_running

Author: tversteeg

testcontainers/src/core/client.rs

@@ -7,8 +7,8 @@ use std::{
 use bollard::{
     auth::DockerCredentials,
     container::{
-        Config, CreateContainerOptions, ListContainersOptions, LogOutput, LogsOptions,
-        RemoveContainerOptions, UploadToContainerOptions,
+        Config, CreateContainerOptions, InspectContainerOptions, ListContainersOptions, LogOutput,
+        LogsOptions, RemoveContainerOptions, UploadToContainerOptions,
     },
     errors::Error as BollardError,
     exec::{CreateExecOptions, StartExecOptions, StartExecResults},
@@ -340,6 +340,22 @@ impl Client {
             .map_err(ClientError::UploadToContainerError)
     }
 
+    pub(crate) async fn container_is_running(
+        &self,
+        container_id: &str,
+    ) -> Result<bool, ClientError> {
+        let container_info = self
+            .bollard
+            .inspect_container(container_id, Some(InspectContainerOptions { size: false }))
+            .await
+            .map_err(ClientError::InspectContainer)?;
+        if let Some(state) = container_info.state {
+            Ok(state.running.unwrap_or_default())
+        } else {
+            Ok(false)
+        }
+    }
+
     pub(crate) async fn pull_image(&self, descriptor: &str) -> Result<(), ClientError> {
         let pull_options = Some(CreateImageOptions {
             from_image: descriptor,

testcontainers/src/core/containers/async_container.rs

@@ -369,6 +369,12 @@ where
         Ok(stderr)
     }
 
+    /// Returns whether the container is still running.
+    pub async fn is_running(&self) -> Result<bool> {
+        let status = self.docker_client.container_is_running(&self.id).await?;
+        Ok(status)
+    }
+
     pub(crate) async fn block_until_ready(&self, ready_conditions: Vec<WaitFor>) -> Result<()> {
         log::debug!("Waiting for container {} to be ready", self.id);
         let id = self.id();

testcontainers/src/core/containers/sync_container.rs

@@ -209,6 +209,11 @@ where
         Ok(stderr)
     }
 
+    /// Returns whether the container is still running.
+    pub async fn is_running(&self) -> Result<bool> {
+        self.rt().block_on(self.async_impl().is_running())
+    }
+
     /// Returns reference to inner `Runtime`. It's safe to unwrap because it's `Some` until `Container` is dropped.
     fn rt(&self) -> &Arc<tokio::runtime::Runtime> {
         &self.inner.as_ref().unwrap().runtime

testcontainers/tests/async_runner.rs

@@ -267,3 +267,22 @@ async fn async_copy_files_to_container() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn async_container_is_running() -> anyhow::Result<()> {
+    let _ = pretty_env_logger::try_init();
+
+    // Container that should run for 1 second
+    let container = GenericImage::new("alpine", "latest")
+        .with_cmd(vec!["sleep", "1"])
+        .start()
+        .await?;
+
+    assert!(container.is_running().await?);
+
+    // After waiting for two seconds it shouldn't be running anymore
+    tokio::time::sleep(Duration::from_secs(2)).await;
+    assert!(!container.is_running().await?);
+
+    Ok(())
+}

testcontainers/tests/sync_runner.rs

@@ -1,6 +1,6 @@
 #![cfg(feature = "blocking")]
 
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
 use testcontainers::{
     core::{
@@ -287,3 +287,20 @@ fn sync_copy_files_to_container() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+fn sync_container_is_running() -> anyhow::Result<()> {
+    let _ = pretty_env_logger::try_init();
+
+    // Container that should run for 1 second
+    let container = GenericImage::new("alpine", "latest")
+        .with_cmd(vec!["sleep", "1"])
+        .start()?;
+
+    assert!(container.is_running()?);
+
+    // After waiting for two seconds it shouldn't be running anymore
+    std::thread::sleep(Duration::from_secs(2));
+    assert!(!container.is_running()?);
+
+    Ok(())
+}