Move to assertj (#5679)

Author: eddumelendez

config/checkstyle/checkstyle.xml

@@ -39,7 +39,6 @@
                       org.mockserver.model.HttpRequest.*,
                       org.mockserver.model.HttpResponse.*,
                       org.rnorth.ducttape.unreliables.Unreliables.*,
-                      org.rnorth.visibleassertions.VisibleAssertions.*,
                       "
             />
         </module>

core/build.gradle

@@ -97,7 +97,6 @@ dependencies {
     // Synthetic JAR used for MountableFileTest and DirectoryTarResourceTest
     testImplementation files('testlib/repo/fakejar/fakejar/0/fakejar-0.jar')
 
-    testImplementation 'org.rnorth.visible-assertions:visible-assertions:2.1.2'
     testImplementation 'org.assertj:assertj-core:3.23.1'
     testImplementation project(':test-support')
 

core/src/test/java/org/testcontainers/DaemonTest.java

@@ -1,15 +1,15 @@
 package org.testcontainers;
 
 import org.junit.Test;
-import org.rnorth.visibleassertions.VisibleAssertions;
 import org.testcontainers.containers.GenericContainer;
 
 import java.io.File;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.stream.Collectors;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
 
 /**
  * This test forks a new JVM, otherwise it's not possible to reliably diff the threads
@@ -30,17 +30,13 @@ public static void main(String[] args) {
 
             Set<Thread> nonDaemonThreads = threads.stream().filter(it -> !it.isDaemon()).collect(Collectors.toSet());
 
-            if (nonDaemonThreads.isEmpty()) {
-                VisibleAssertions.pass("All threads marked as daemon");
-            } else {
+            if (!nonDaemonThreads.isEmpty()) {
                 String nonDaemonThreadNames = nonDaemonThreads
                     .stream()
                     .map(Thread::getName)
                     .collect(Collectors.joining("\n", "\n", ""));
 
-                VisibleAssertions.fail(
-                    "Expected all threads to be daemons but the following are not:\n" + nonDaemonThreadNames
-                );
+                fail("Expected all threads to be daemons but the following are not:\n" + nonDaemonThreadNames);
             }
         } finally {
             if (genericContainer != null) {
@@ -59,6 +55,6 @@ public void testThatAllThreadsAreDaemons() throws Exception {
             DaemonTest.class.getCanonicalName()
         );
 
-        assertEquals(0, processBuilder.inheritIO().start().waitFor());
+        assertThat(processBuilder.inheritIO().start().waitFor()).isZero();
     }
 }

core/src/test/java/org/testcontainers/containers/ContainerStateTest.java

@@ -1,13 +1,13 @@
 package org.testcontainers.containers;
 
-import org.assertj.core.api.Assertions;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
 import java.util.Collections;
 import java.util.List;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.doCallRealMethod;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -44,6 +44,6 @@ public void test() {
         when(containerState.getPortBindings()).thenReturn(Collections.singletonList(testSet));
 
         List<Integer> result = containerState.getBoundPortNumbers();
-        Assertions.assertThat(result).hasSameElementsAs(expectedResult);
+        assertThat(result).hasSameElementsAs(expectedResult);
     }
 }

core/src/test/java/org/testcontainers/containers/DockerComposeContainerWithServicesTest.java

@@ -1,6 +1,7 @@
 package org.testcontainers.containers;
 
 import org.junit.Test;
+import org.rnorth.ducttape.TimeoutException;
 import org.testcontainers.containers.wait.strategy.Wait;
 
 import java.io.File;
@@ -9,8 +10,8 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import static org.rnorth.visibleassertions.VisibleAssertions.assertEquals;
-import static org.rnorth.visibleassertions.VisibleAssertions.assertThrows;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.catchThrowable;
 
 public class DockerComposeContainerWithServicesTest {
 
@@ -92,10 +93,8 @@ public void testScaleInComposeFileIsRespected() {
 
     @Test
     public void testStartupTimeoutSetsTheHighestTimeout() {
-        assertThrows(
-            "We expect a timeout from the startup timeout",
-            org.rnorth.ducttape.TimeoutException.class,
-            () -> {
+        assertThat(
+            catchThrowable(() -> {
                 try (
                     DockerComposeContainer<?> compose = new DockerComposeContainer<>(SIMPLE_COMPOSE_FILE)
                         .withServices("redis")
@@ -108,8 +107,10 @@ public void testStartupTimeoutSetsTheHighestTimeout() {
                 ) {
                     compose.start();
                 }
-            }
-        );
+            })
+        )
+            .as("We expect a timeout from the startup timeout")
+            .isInstanceOf(TimeoutException.class);
     }
 
     private void verifyStartedContainers(final DockerComposeContainer<?> compose, final String... names) {
@@ -119,16 +120,16 @@ private void verifyStartedContainers(final DockerComposeContainer<?> compose, fi
             .flatMap(container -> Stream.of(container.getNames()))
             .collect(Collectors.toList());
 
-        assertEquals(
-            "number of running services of docker-compose is the same as length of listOfServices",
-            names.length,
-            containerNames.size()
-        );
+        assertThat(containerNames)
+            .as("number of running services of docker-compose is the same as length of listOfServices")
+            .hasSize(names.length);
 
         for (final String expectedName : names) {
             final long matches = containerNames.stream().filter(foundName -> foundName.endsWith(expectedName)).count();
 
-            assertEquals("container with name starting '" + expectedName + "' should be running", 1L, matches);
+            assertThat(matches)
+                .as("container with name starting '" + expectedName + "' should be running")
+                .isEqualTo(1L);
         }
     }
 }

core/src/test/java/org/testcontainers/containers/DockerComposeFilesTest.java

@@ -1,20 +1,20 @@
 package org.testcontainers.containers;
 
 import com.google.common.collect.Lists;
-import org.assertj.core.api.Assertions;
 import org.junit.Test;
 
 import java.io.File;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class DockerComposeFilesTest {
 
     @Test
     public void shouldGetDependencyImages() {
         DockerComposeFiles dockerComposeFiles = new DockerComposeFiles(
             Lists.newArrayList(new File("src/test/resources/docker-compose-imagename-parsing-v2.yml"))
         );
-        Assertions
-            .assertThat(dockerComposeFiles.getDependencyImages())
+        assertThat(dockerComposeFiles.getDependencyImages())
             .containsExactlyInAnyOrder("postgres:latest", "redis:latest", "mysql:latest");
     }
 
@@ -26,8 +26,7 @@ public void shouldGetDependencyImagesWhenOverriding() {
                 new File("src/test/resources/docker-compose-imagename-overriding-b.yml")
             )
         );
-        Assertions
-            .assertThat(dockerComposeFiles.getDependencyImages())
+        assertThat(dockerComposeFiles.getDependencyImages())
             .containsExactlyInAnyOrder("alpine:3.16", "redis:b", "mysql:b", "aservice:latest");
     }
 }

core/src/test/java/org/testcontainers/containers/DockerComposeOverridesTest.java

@@ -16,9 +16,6 @@
 import java.util.Arrays;
 import java.util.concurrent.TimeUnit;
 
-import static org.rnorth.visibleassertions.VisibleAssertions.info;
-import static org.rnorth.visibleassertions.VisibleAssertions.pass;
-
 @RunWith(Parameterized.class)
 public class DockerComposeOverridesTest {
 
@@ -100,11 +97,9 @@ public void test() {
                     while (br.ready()) {
                         String line = br.readLine();
                         if (line.contains(expectedEnvVar)) {
-                            pass("Mapped environment variable was found");
                             return true;
                         }
                     }
-                    info("Mapped environment variable was not found yet - process probably not ready");
                     Uninterruptibles.sleepUninterruptibly(100, TimeUnit.MILLISECONDS);
                     return false;
                 }

core/src/test/java/org/testcontainers/containers/ExposedHostTest.java

@@ -13,7 +13,7 @@
 import java.io.OutputStream;
 import java.net.InetSocketAddress;
 
-import static org.rnorth.visibleassertions.VisibleAssertions.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class ExposedHostTest {
 
@@ -95,7 +95,7 @@ protected void assertResponse(GenericContainer<?> container, int port) {
                 .execInContainer("wget", "-O", "-", "http://host.testcontainers.internal:" + port)
                 .getStdout();
 
-            assertEquals("received response", "Hello World!", response);
+            assertThat(response).as("received response").isEqualTo("Hello World!");
         } finally {
             container.stop();
         }

core/src/test/java/org/testcontainers/containers/GenericContainerTest.java

@@ -6,7 +6,6 @@
 import com.github.dockerjava.api.model.ExposedPort;
 import com.github.dockerjava.api.model.Info;
 import com.github.dockerjava.api.model.Ports;
-import com.google.common.primitives.Ints;
 import lombok.RequiredArgsConstructor;
 import lombok.SneakyThrows;
 import lombok.experimental.FieldDefaults;
@@ -30,10 +29,9 @@
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.rnorth.visibleassertions.VisibleAssertions.assertEquals;
-import static org.rnorth.visibleassertions.VisibleAssertions.assertThrows;
-import static org.rnorth.visibleassertions.VisibleAssertions.assertTrue;
+import static org.assertj.core.api.Assertions.catchThrowable;
 
 public class GenericContainerTest {
 
@@ -119,28 +117,20 @@ public void shouldOnlyPublishExposedPorts() {
                 .map(ExposedPort::getPort)
                 .collect(Collectors.toList());
 
-            assertEquals(
-                "the exposed ports are all of those EXPOSEd by the image",
-                Ints.asList(8080, 8081),
-                exposedPorts
-            );
+            assertThat(exposedPorts).as("the exposed ports are all of those EXPOSEd by the image").contains(8080, 8081);
 
             Map<ExposedPort, Ports.Binding[]> hostBindings = inspectedContainer
                 .getHostConfig()
                 .getPortBindings()
                 .getBindings();
-            assertEquals("only 1 port is bound on the host (published)", 1, hostBindings.size());
+            assertThat(hostBindings).as("only 1 port is bound on the host (published)").hasSize(1);
 
             Integer mappedPort = container.getMappedPort(8080);
-            assertTrue("port 8080 is bound to a different port on the host", mappedPort != 8080);
+            assertThat(mappedPort != 8080).as("port 8080 is bound to a different port on the host").isTrue();
 
-            assertThrows(
-                "trying to get a non-bound port mapping fails",
-                IllegalArgumentException.class,
-                () -> {
-                    container.getMappedPort(8081);
-                }
-            );
+            assertThat(catchThrowable(() -> container.getMappedPort(8081)))
+                .as("trying to get a non-bound port mapping fails")
+                .isInstanceOf(IllegalArgumentException.class);
         }
     }
 
@@ -161,8 +151,8 @@ public void shouldWaitUntilExposedPortIsMapped() {
         ) {
             container.start();
 
-            assertEquals("Only withExposedPort should be exposed", 1, container.getExposedPorts().size());
-            assertTrue("withExposedPort should be exposed", container.getExposedPorts().contains(8080));
+            assertThat(container.getExposedPorts()).as("Only withExposedPort should be exposed").hasSize(1);
+            assertThat(container.getExposedPorts()).as("withExposedPort should be exposed").contains(8080);
         }
     }
 

core/src/test/java/org/testcontainers/containers/NetworkTest.java

@@ -7,9 +7,7 @@
 import org.testcontainers.DockerClientFactory;
 import org.testcontainers.TestImages;
 
-import static org.rnorth.visibleassertions.VisibleAssertions.assertEquals;
-import static org.rnorth.visibleassertions.VisibleAssertions.assertNotEquals;
-import static org.rnorth.visibleassertions.VisibleAssertions.assertNotNull;
+import static org.assertj.core.api.Assertions.assertThat;
 
 @RunWith(Enclosed.class)
 public class NetworkTest {
@@ -33,7 +31,7 @@ public static class WithRules {
         @Test
         public void testNetworkSupport() throws Exception {
             String response = bar.execInContainer("wget", "-O", "-", "http://foo:8080").getStdout();
-            assertEquals("received response", "yay", response);
+            assertThat(response).as("received response").isEqualTo("yay");
         }
     }
 
@@ -60,7 +58,7 @@ public void testNetworkSupport() throws Exception {
                 bar.start();
 
                 String response = bar.execInContainer("wget", "-O", "-", "http://foo:8080").getStdout();
-                assertEquals("received response", "yay", response);
+                assertThat(response).as("received response").isEqualTo("yay");
             }
             // }
         }
@@ -69,11 +67,11 @@ public void testNetworkSupport() throws Exception {
         public void testBuilder() {
             try (Network network = Network.builder().driver("macvlan").build()) {
                 String id = network.getId();
-                assertEquals(
-                    "Flag is set",
-                    "macvlan",
+                assertThat(
                     DockerClientFactory.instance().client().inspectNetworkCmd().withNetworkId(id).exec().getDriver()
-                );
+                )
+                    .as("Flag is set")
+                    .isEqualTo("macvlan");
             }
         }
 
@@ -83,36 +81,35 @@ public void testModifiers() {
                 Network network = Network.builder().createNetworkCmdModifier(cmd -> cmd.withDriver("macvlan")).build()
             ) {
                 String id = network.getId();
-                assertEquals(
-                    "Flag is set",
-                    "macvlan",
+                assertThat(
                     DockerClientFactory.instance().client().inspectNetworkCmd().withNetworkId(id).exec().getDriver()
-                );
+                )
+                    .as("Flag is set")
+                    .isEqualTo("macvlan");
             }
         }
 
         @Test
         public void testReusability() {
             try (Network network = Network.newNetwork()) {
                 String firstId = network.getId();
-                assertNotNull(
-                    "Network exists",
-                    DockerClientFactory.instance().client().inspectNetworkCmd().withNetworkId(firstId).exec()
-                );
+                assertThat(DockerClientFactory.instance().client().inspectNetworkCmd().withNetworkId(firstId).exec())
+                    .as("Network exists")
+                    .isNotNull();
 
                 network.close();
 
-                assertNotEquals(
-                    "New network created",
-                    firstId,
+                assertThat(
                     DockerClientFactory
                         .instance()
                         .client()
                         .inspectNetworkCmd()
                         .withNetworkId(network.getId())
                         .exec()
                         .getId()
-                );
+                )
+                    .as("New network created")
+                    .isNotEqualTo(firstId);
             }
         }
     }