test: switch to testcontainers/helloworld and reduce some flakiness (#855)

Author: DDtKey

testcontainers/src/buildables/generic.rs

@@ -24,7 +24,7 @@ use crate::{
 ///
 /// #[tokio::test]
 /// async fn test_hello() -> anyhow::Result<()> {
-///     let image = GenericBuildableImage::new("hello-world", "latest")
+///     let image = GenericBuildableImage::new("hello-world", "my-tag")
 ///         .with_dockerfile_string(
 ///             r#"FROM alpine:latest
 ///             COPY hello.sh /usr/local/bin/

testcontainers/src/core/containers/async_container.rs

@@ -542,7 +542,7 @@ mod tests {
 
     #[tokio::test]
     async fn async_logs_are_accessible() -> anyhow::Result<()> {
-        let image = GenericImage::new("testcontainers/helloworld", "1.2.0");
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0");
         let container = image.start().await?;
 
         let stderr = container.stderr(true);
@@ -634,7 +634,7 @@ mod tests {
             ("test-name", "async_containers_are_reused"),
         ];
 
-        let initial_image = GenericImage::new("testcontainers/helloworld", "1.2.0")
+        let initial_image = GenericImage::new("testcontainers/helloworld", "1.3.0")
             .with_reuse(crate::ReuseDirective::CurrentSession)
             .with_labels(labels);
 
@@ -698,7 +698,7 @@ mod tests {
             ("test-name", "async_reused_containers_are_not_confused"),
         ];
 
-        let initial_image = GenericImage::new("testcontainers/helloworld", "1.2.0")
+        let initial_image = GenericImage::new("testcontainers/helloworld", "1.3.0")
             .with_reuse(ReuseDirective::Always)
             .with_labels(labels);
 
@@ -758,7 +758,7 @@ mod tests {
 
         let client = crate::core::client::docker_client_instance().await?;
 
-        let image = GenericImage::new("testcontainers/helloworld", "1.2.0")
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0")
             .with_reuse(ReuseDirective::Always)
             .with_labels([
                 ("foo", "bar"),
@@ -798,6 +798,8 @@ mod tests {
     #[cfg(feature = "http_wait_plain")]
     #[tokio::test]
     async fn exec_before_ready_is_ran() {
+        use crate::core::CmdWaitFor;
+
         struct ExecBeforeReady {}
 
         impl Image for ExecBeforeReady {
@@ -830,14 +832,18 @@ mod tests {
                     "/bin/sh",
                     "-c",
                     "echo 'exec_before_ready ran!' > /opt/hello",
-                ])])
+                ])
+                .with_cmd_ready_condition(CmdWaitFor::exit())])
             }
         }
 
         let container = ExecBeforeReady {};
         let container = container.start().await.unwrap();
         let mut exec_result = container
-            .exec(ExecCommand::new(vec!["cat", "/opt/hello"]))
+            .exec(
+                ExecCommand::new(vec!["cat", "/opt/hello"])
+                    .with_cmd_ready_condition(CmdWaitFor::exit()),
+            )
             .await
             .unwrap();
         let stdout = exec_result.stdout_to_vec().await.unwrap();
@@ -852,11 +858,11 @@ mod tests {
 
         impl Image for HelloWorld {
             fn name(&self) -> &str {
-                "hello-world"
+                "testcontainers/helloworld"
             }
 
             fn tag(&self) -> &str {
-                "latest"
+                "1.3.0"
             }
 
             fn ready_conditions(&self) -> Vec<WaitFor> {
@@ -865,7 +871,7 @@ mod tests {
         }
 
         let container = HelloWorld {}
-            .with_ready_conditions(vec![WaitFor::message_on_stdout("Hello from Docker!")]);
+            .with_ready_conditions(vec![WaitFor::message_on_stderr("Ready, listening on")]);
         let _ = container.start().await.unwrap();
     }
 }

testcontainers/src/core/containers/sync_container.rs

@@ -257,15 +257,15 @@ mod test {
 
     impl Image for HelloWorld {
         fn name(&self) -> &str {
-            "hello-world"
+            "testcontainers/helloworld"
         }
 
         fn tag(&self) -> &str {
-            "latest"
+            "1.3.0"
         }
 
         fn ready_conditions(&self) -> Vec<WaitFor> {
-            vec![WaitFor::message_on_stdout("Hello from Docker!")]
+            vec![WaitFor::message_on_stderr("Ready, listening on")]
         }
     }
 
@@ -324,7 +324,7 @@ mod test {
 
     #[test]
     fn sync_logs_are_accessible() -> anyhow::Result<()> {
-        let image = GenericImage::new("testcontainers/helloworld", "1.2.0");
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0");
         let container = image.start()?;
 
         let stderr = container.stderr(true);

testcontainers/src/core/ports.rs

@@ -320,7 +320,7 @@ mod tests {
     "Cmd": [
       "/hello"
     ],
-    "Image": "hello-world",
+    "Image": "testcontainers/helloworld",
     "Volumes": null,
     "WorkingDir": "",
     "Entrypoint": null,

testcontainers/src/images/generic.rs

@@ -107,7 +107,7 @@ mod tests {
 
     #[test]
     fn should_return_env_vars() {
-        let image = GenericImage::new("hello-world", "latest")
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0")
             .with_env_var("one-key", "one-value")
             .with_env_var("two-key", "two-value");
 

testcontainers/src/runners/async_runner.rs

@@ -441,7 +441,7 @@ mod tests {
             ),
         ]);
 
-        let image = GenericImage::new("hello-world", "latest").with_labels(&labels);
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0").with_labels(&labels);
 
         let container = {
             #[cfg(not(feature = "reusable-containers"))]
@@ -494,7 +494,9 @@ mod tests {
     async fn async_run_command_should_expose_all_ports_if_no_explicit_mapping_requested(
     ) -> anyhow::Result<()> {
         let client = Client::lazy_client().await?;
-        let container = GenericImage::new("hello-world", "latest").start().await?;
+        let container = GenericImage::new("testcontainers/helloworld", "1.3.0")
+            .start()
+            .await?;
 
         let container_details = client.inspect(container.id()).await?;
         let publish_ports = container_details
@@ -588,18 +590,16 @@ mod tests {
         let client = Client::lazy_client().await?;
         let _ = pretty_env_logger::try_init();
 
-        let udp_port = 1000;
-        let sctp_port = 2000;
+        let udp_port = 1000.udp();
+        let sctp_port = 2000.sctp();
 
         let generic_server = get_server_container()
             .await
             // Explicitly expose the port, which otherwise would not be available.
-            .with_exposed_port(udp_port.udp())
-            .with_exposed_port(sctp_port.sctp());
+            .with_exposed_port(udp_port)
+            .with_exposed_port(sctp_port);
 
         let container = generic_server.start().await?;
-        container.get_host_port_ipv4(udp_port.udp()).await?;
-        container.get_host_port_ipv4(sctp_port.sctp()).await?;
 
         let container_details = client.inspect(container.id()).await?;
 
@@ -623,15 +623,20 @@ mod tests {
         expected_ports.push(sctp_expected_port);
         expected_ports.push(tcp_expected_port);
 
-        assert_eq!(current_ports, expected_ports);
+        assert!(
+            expected_ports
+                .iter()
+                .all(|port| current_ports.contains(port)),
+            "exposed ports: {current_ports:?} doesn't contain all expected ports: {expected_ports:?}"
+        );
 
         Ok(())
     }
 
     #[tokio::test]
     async fn async_run_command_should_expose_only_requested_ports() -> anyhow::Result<()> {
         let client = Client::lazy_client().await?;
-        let image = GenericImage::new("hello-world", "latest");
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0");
         let container = image
             .with_mapped_port(123, 456.tcp())
             .with_mapped_port(555, 888.tcp())
@@ -665,7 +670,7 @@ mod tests {
         let udp_port = 1000;
         let sctp_port = 2000;
 
-        let image = GenericImage::new("hello-world", "latest");
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0");
         let container = image
             .with_mapped_port(123, udp_port.udp())
             .with_mapped_port(555, sctp_port.sctp())
@@ -700,7 +705,7 @@ mod tests {
     #[tokio::test]
     async fn async_run_command_should_include_network() -> anyhow::Result<()> {
         let client = Client::lazy_client().await?;
-        let image = GenericImage::new("hello-world", "latest");
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0");
         let container = image.with_network("awesome-net-1").start().await?;
 
         let container_details = client.inspect(container.id()).await?;
@@ -720,7 +725,7 @@ mod tests {
     #[tokio::test]
     async fn async_run_command_should_include_name() -> anyhow::Result<()> {
         let client = Client::lazy_client().await?;
-        let image = GenericImage::new("hello-world", "latest");
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0");
         let container = image
             .with_container_name("async_hello_container")
             .start()
@@ -735,7 +740,7 @@ mod tests {
     #[tokio::test]
     async fn async_should_create_network_if_image_needs_it_and_drop_it_in_the_end(
     ) -> anyhow::Result<()> {
-        let hello_world = GenericImage::new("hello-world", "latest");
+        let hello_world = GenericImage::new("testcontainers/helloworld", "1.3.0");
 
         {
             let client = Client::lazy_client().await?;
@@ -800,7 +805,7 @@ mod tests {
     #[tokio::test]
     async fn async_run_command_should_set_shared_memory_size() -> anyhow::Result<()> {
         let client = Client::lazy_client().await?;
-        let image = GenericImage::new("hello-world", "latest");
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0");
         let container = image.with_shm_size(1_000_000).start().await?;
 
         let container_details = client.inspect(container.id()).await?;
@@ -816,7 +821,7 @@ mod tests {
 
     #[tokio::test]
     async fn async_run_command_should_include_privileged() -> anyhow::Result<()> {
-        let image = GenericImage::new("hello-world", "latest");
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0");
         let container = image.with_privileged(true).start().await?;
 
         let client = Client::lazy_client().await?;
@@ -833,7 +838,7 @@ mod tests {
 
     #[tokio::test]
     async fn async_run_command_should_have_cap_add() -> anyhow::Result<()> {
-        let image = GenericImage::new("hello-world", "latest");
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0");
         let expected_capability = "NET_ADMIN";
         let container = image
             .with_cap_add(expected_capability.to_string())
@@ -860,7 +865,7 @@ mod tests {
 
     #[tokio::test]
     async fn async_run_command_should_have_cap_drop() -> anyhow::Result<()> {
-        let image = GenericImage::new("hello-world", "latest");
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0");
         let expected_capability = "AUDIT_WRITE";
         let container = image
             .with_cap_drop(expected_capability.to_string())
@@ -887,7 +892,7 @@ mod tests {
 
     #[tokio::test]
     async fn async_run_command_should_include_ulimits() -> anyhow::Result<()> {
-        let image = GenericImage::new("hello-world", "latest");
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0");
         let container = image.with_ulimit("nofile", 123, Some(456)).start().await?;
 
         let client = Client::lazy_client().await?;
@@ -908,7 +913,7 @@ mod tests {
 
     #[tokio::test]
     async fn async_run_command_should_have_host_cgroupns_mode() -> anyhow::Result<()> {
-        let image = GenericImage::new("hello-world", "latest");
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0");
         let container = image.with_cgroupns_mode(CgroupnsMode::Host).start().await?;
 
         let client = Client::lazy_client().await?;
@@ -930,7 +935,7 @@ mod tests {
 
     #[tokio::test]
     async fn async_run_command_should_have_private_cgroupns_mode() -> anyhow::Result<()> {
-        let image = GenericImage::new("hello-world", "latest");
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0");
         let container = image
             .with_cgroupns_mode(CgroupnsMode::Private)
             .start()
@@ -955,7 +960,7 @@ mod tests {
 
     #[tokio::test]
     async fn async_run_command_should_have_host_userns_mode() -> anyhow::Result<()> {
-        let image = GenericImage::new("hello-world", "latest");
+        let image = GenericImage::new("testcontainers/helloworld", "1.3.0");
         let container = image.with_userns_mode("host").start().await?;
 
         let client = Client::lazy_client().await?;
@@ -972,7 +977,7 @@ mod tests {
 
     #[tokio::test]
     async fn async_run_command_should_have_working_dir() -> anyhow::Result<()> {
-        let image = GenericImage::new("hello-world", "latest");
+        let image = GenericImage::new("testcontainers/helloworld", "1.2.0");
         let expected_working_dir = "/foo";
         let container = image.with_working_dir(expected_working_dir).start().await?;