feat: add Container*::exit_code

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,24 @@ impl Client {
             .map_err(ClientError::UploadToContainerError)
     }
 
+    pub(crate) async fn container_exit_code(
+        &self,
+        container_id: &str,
+    ) -> Result<Option<i64>, ClientError> {
+        let container_info = self
+            .bollard
+            .inspect_container(container_id, Some(InspectContainerOptions { size: false }))
+            .await
+            .map_err(ClientError::InspectContainer)?;
+        let Some(state) = container_info.state else {
+            return Ok(None);
+        };
+        if state.running == Some(true) {
+            return Ok(None);
+        }
+        Ok(state.exit_code)
+    }
+
     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 `Some(exit_code)` when the container is finished and `None` when the container is still running.
+    pub async fn exit_code(&self) -> Result<Option<i64>> {
+        let exit_code = self.docker_client.container_exit_code(&self.id).await?;
+        Ok(exit_code)
+    }
+
     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 `Some(exit_code)` when the container is finished and `None` when the container is still running.
+    pub fn exit_code(&self) -> Result<Option<i64>> {
+        self.rt().block_on(self.async_impl().exit_code())
+    }
+
     /// 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_exit_code() -> anyhow::Result<()> {
+    let _ = pretty_env_logger::try_init();
+
+    // Container that should run for 1 second and exit with a specific doe
+    let container = GenericImage::new("alpine", "latest")
+        .with_cmd(vec!["/bin/sh", "-c", "sleep 1 && exit 4"])
+        .start()
+        .await?;
+
+    assert_eq!(container.exit_code().await?, None);
+
+    // After waiting for two seconds it shouldn't be running anymore
+    tokio::time::sleep(Duration::from_secs(2)).await;
+    assert_eq!(container.exit_code().await?, Some(4));
+
+    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,21 @@ fn sync_copy_files_to_container() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn sync_container_exit_code() -> anyhow::Result<()> {
+    let _ = pretty_env_logger::try_init();
+
+    // Container that should run for 1 second and exit with a specific doe
+    let container = GenericImage::new("alpine", "latest")
+        .with_cmd(vec!["/bin/sh", "-c", "sleep 1 && exit 4"])
+        .start()?;
+
+    assert_eq!(container.exit_code()?, None);
+
+    // After waiting for two seconds it shouldn't be running anymore
+    std::thread::sleep(Duration::from_secs(2));
+    assert_eq!(container.exit_code()?, Some(4));
+
+    Ok(())
+}