Update testcontainers to 1.15.0-rc2 (fix for a breaking change that appeared in Docker for Mac v2.4.0.0 testcontainers/testcontainers-java#3159)

Author: Anastasiia Smirnova

embedded-aerospike/src/main/java/com/playtika/test/aerospike/EmbeddedAerospikeBootstrapConfiguration.java

@@ -82,7 +82,7 @@ public GenericContainer aerospike(AerospikeWaitStrategy aerospikeWaitStrategy,
                         .withEnv("SERVICE_PORT", String.valueOf(properties.port))
                         .withEnv("MEM_GB", String.valueOf(1))
                         .withEnv("STORAGE_GB", String.valueOf(1))
-                        .withCreateContainerCmdModifier(cmd -> cmd.withCapAdd(Capability.NET_ADMIN))
+                        .withCreateContainerCmdModifier(cmd -> cmd.getHostConfig().withCapAdd(Capability.NET_ADMIN))
                         .waitingFor(waitStrategy)
                         .withReuse(properties.isReuseContainer())
                         .withStartupTimeout(properties.getTimeoutDuration());

embedded-couchbase/src/main/java/com/playtika/test/couchbase/EmbeddedCouchbaseBootstrapConfiguration.java

@@ -63,7 +63,7 @@ public CouchbaseContainer couchbase(ConfigurableEnvironment environment,
                 .withEnabledServices(properties.getServices())
                 .withCredentials(properties.getUser(), properties.getPassword())
                 .withReuse(properties.isReuseContainer())
-                .withCreateContainerCmdModifier(cmd -> cmd.withCapAdd(Capability.NET_ADMIN));
+                .withCreateContainerCmdModifier(cmd -> cmd.getHostConfig().withCapAdd(Capability.NET_ADMIN));
         couchbase.start();
 
         registerCouchbaseEnvironment(couchbase, environment, properties);

embedded-elasticsearch/src/main/java/com/playtika/test/elasticsearch/ElasticSearchContainerFactory.java

@@ -27,24 +27,25 @@
 import com.playtika.test.elasticsearch.rest.CreateIndex;
 import com.playtika.test.elasticsearch.rest.WaitForGreenStatus;
 import org.slf4j.Logger;
-import org.testcontainers.containers.FixedHostPortGenericContainer;
 import org.testcontainers.containers.wait.strategy.HostPortWaitStrategy;
 import org.testcontainers.containers.wait.strategy.WaitAllStrategy;
 import org.testcontainers.containers.wait.strategy.WaitStrategy;
 import org.testcontainers.elasticsearch.ElasticsearchContainer;
+import org.testcontainers.utility.DockerImageName;
 
 import static com.playtika.test.common.utils.ContainerUtils.DEFAULT_CONTAINER_WAIT_DURATION;
 import static com.playtika.test.common.utils.ContainerUtils.containerLogsConsumer;
 
 class ElasticSearchContainerFactory {
 
     static ElasticsearchContainer create(ElasticSearchProperties properties, Logger containerLogger) {
-        return new ElasticsearchContainer(properties.dockerImage)
+        return new ElasticsearchContainer(DockerImageName.parse(properties.dockerImage)
+                .asCompatibleSubstituteFor("docker.elastic.co/elasticsearch/elasticsearch"))
                 .withExposedPorts(properties.httpPort, properties.transportPort)
                 .withEnv("cluster.name", properties.getClusterName())
                 .withEnv("discovery.type", "single-node")
                 .withEnv("ES_JAVA_OPTS", getJavaOpts(properties))
-                .withCreateContainerCmdModifier(cmd -> cmd.withCapAdd(Capability.NET_ADMIN))
+                .withCreateContainerCmdModifier(cmd -> cmd.getHostConfig().withCapAdd(Capability.NET_ADMIN))
                 .withLogConsumer(containerLogsConsumer(containerLogger))
                 .waitingFor(getCompositeWaitStrategy(properties))
                 .withReuse(properties.isReuseContainer())

embedded-elasticsearch/src/test/resources/log4j2.xml

@@ -6,7 +6,7 @@
         </Console>
     </Appenders>
     <Loggers>
-        <Logger name="com.playtika.test" level="debug"/>
+        <Logger name="com.playtika.test" level="info"/>
         <Root level="error">
             <AppenderRef ref="console"/>
         </Root>

embedded-kafka/src/main/java/com/playtika/test/kafka/KafkaTopicsConfigurer.java

@@ -23,17 +23,19 @@
  */
 package com.playtika.test.kafka;
 
-import com.playtika.test.common.utils.ContainerUtils;
 import com.playtika.test.kafka.properties.KafkaConfigurationProperties;
 import com.playtika.test.kafka.properties.ZookeeperConfigurationProperties;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.testcontainers.containers.Container;
 import org.testcontainers.containers.GenericContainer;
 
 import javax.annotation.PostConstruct;
 import java.util.Collection;
 
+import static com.playtika.test.common.utils.ContainerUtils.executeInContainer;
+
 @Slf4j
 @RequiredArgsConstructor
 @Getter
@@ -60,9 +62,8 @@ public void createTopics(Collection<String> topics) {
 
     private void createTopic(String topic) {
         String[] createTopicCmd = getCreateTopicCmd(topic, zookeeperProperties.getZookeeperConnect());
-        ContainerUtils.ExecCmdResult output = ContainerUtils.execCmd(this.kafka.getDockerClient(), this.kafka.getContainerId(), createTopicCmd);
-        log.debug("Topic={} creation cmd='{}' exitCode={} : {}",
-                topic, createTopicCmd, output.getExitCode(), output.getOutput());
+        Container.ExecResult execResult = executeInContainer(this.kafka, createTopicCmd);
+        log.debug("Topic={} creation cmd='{}' execResult={}", topic, createTopicCmd, execResult);
     }
 
     private void restrictTopics(String username, Collection<String> topics) {
@@ -71,11 +72,11 @@ private void restrictTopics(String username, Collection<String> topics) {
             for (String topic : topics) {
                 String[] topicConsumerACLsCmd = getTopicConsumerACLCmd(username, topic, zookeeperProperties.getZookeeperConnect());
                 String[] topicProducerACLsCmd = getTopicProducerACLCmd(username, topic, zookeeperProperties.getZookeeperConnect());
-                ContainerUtils.ExecCmdResult topicConsumerACLsOutput = ContainerUtils.execCmd(this.kafka.getDockerClient(), this.kafka.getContainerId(), topicConsumerACLsCmd);
-                ContainerUtils.ExecCmdResult topicProducerACLsOutput = ContainerUtils.execCmd(this.kafka.getDockerClient(), this.kafka.getContainerId(), topicProducerACLsCmd);
-                log.debug("Topic={} consumer ACLs cmd='{}' exitCode={} : {}, producer ACLs cmd='{}' exitCode={} : {}",
-                        topic, topicConsumerACLsCmd, topicConsumerACLsOutput.getExitCode(), topicConsumerACLsOutput.getOutput(),
-                        topicProducerACLsCmd, topicProducerACLsOutput.getExitCode(), topicProducerACLsOutput.getOutput());
+                Container.ExecResult topicConsumerACLsOutput = executeInContainer(this.kafka, topicConsumerACLsCmd);
+                Container.ExecResult topicProducerACLsOutput = executeInContainer(this.kafka, topicProducerACLsCmd);
+                log.debug("Topic={} consumer ACLs cmd='{}' execResult={}, producer ACLs cmd='{}' execResult={}",
+                        topic, topicConsumerACLsCmd, topicConsumerACLsOutput,
+                        topicProducerACLsCmd, topicProducerACLsOutput.getExitCode());
             }
             log.info("Created ACLs for Kafka topics: {}", topics);
         }

embedded-kafka/src/main/java/com/playtika/test/kafka/configuration/KafkaContainerConfiguration.java

@@ -102,7 +102,7 @@ public String getBootstrapServers() {
         }
                 .withLogConsumer(containerLogsConsumer(log))
                 .withCreateContainerCmdModifier(cmd -> cmd.withHostName(KAFKA_HOST_NAME))
-                .withCreateContainerCmdModifier(cmd -> cmd.withCapAdd(Capability.NET_ADMIN))
+                .withCreateContainerCmdModifier(cmd -> cmd.getHostConfig().withCapAdd(Capability.NET_ADMIN))
                 .withEmbeddedZookeeper()
                 .withEnv("KAFKA_BROKER_ID", "-1")
                 //see: https://stackoverflow.com/questions/41868161/kafka-in-kubernetes-cluster-how-to-publish-consume-messages-from-outside-of-kub

embedded-kafka/src/main/java/com/playtika/test/kafka/configuration/SchemaRegistryContainerConfiguration.java

@@ -64,7 +64,7 @@ public GenericContainer schemaRegistry(
         GenericContainer schemaRegistry = new FixedHostPortGenericContainer<>(properties.getDockerImage())
                 .withLogConsumer(containerLogsConsumer(log))
                 .withCreateContainerCmdModifier(cmd -> cmd.withHostName(SCHEMA_REGISTRY_HOST_NAME))
-                .withCreateContainerCmdModifier(cmd -> cmd.withCapAdd(Capability.NET_ADMIN))
+                .withCreateContainerCmdModifier(cmd -> cmd.getHostConfig().withCapAdd(Capability.NET_ADMIN))
                 .withEnv("SCHEMA_REGISTRY_KAFKASTORE_BOOTSTRAP_SERVERS", "PLAINTEXT://" + kafkaContainerBrokerList)
                 .withEnv("SCHEMA_REGISTRY_HOST_NAME", SCHEMA_REGISTRY_HOST_NAME)
                 .withEnv("SCHEMA_REGISTRY_LISTENERS", "http://0.0.0.0:" + properties.getPort())

embedded-keycloak/src/test/java/com/playtika/test/keycloak/util/RealmInfo.java

@@ -1,10 +1,10 @@
 package com.playtika.test.keycloak.util;
 
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;
-import org.testcontainers.shaded.com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import org.testcontainers.shaded.com.fasterxml.jackson.annotation.JsonProperty;
 
 @ToString
 @Getter

embedded-mariadb/src/main/java/com/playtika/test/mariadb/EmbeddedMariaDBBootstrapConfiguration.java

@@ -66,7 +66,7 @@ public MariaDBContainer mariadb(ConfigurableEnvironment environment,
                                 "--max_allowed_packet=" + properties.getMaxAllowedPacket())
                         .withLogConsumer(containerLogsConsumer(log))
                         .withExposedPorts(properties.port)
-                        .withCreateContainerCmdModifier(cmd -> cmd.withCapAdd(Capability.NET_ADMIN))
+                        .withCreateContainerCmdModifier(cmd -> cmd.getHostConfig().withCapAdd(Capability.NET_ADMIN))
                         .withStartupTimeout(properties.getTimeoutDuration())
                         .withInitScript(properties.initScriptPath)
                         .withReuse(properties.isReuseContainer());

embedded-memsql/src/main/java/com/playtika/test/memsql/EmbeddedMemSqlBootstrapConfiguration.java

@@ -68,7 +68,7 @@ public GenericContainer memsql(ConfigurableEnvironment environment,
                 .withLogConsumer(containerLogsConsumer(log))
                 .withExposedPorts(properties.port)
                 .withCopyFileToContainer(MountableFile.forClasspathResource("mem.sql"), "/schema.sql")
-                .withCreateContainerCmdModifier(cmd -> cmd.withCapAdd(Capability.NET_ADMIN))
+                .withCreateContainerCmdModifier(cmd -> cmd.getHostConfig().withCapAdd(Capability.NET_ADMIN))
                 .waitingFor(memSqlStatusCheck)
                 .withStartupTimeout(properties.getTimeoutDuration())
                 .withReuse(properties.isReuseContainer());

embedded-minio/src/main/java/com/playtika/test/minio/EmbeddedMinioBootstrapConfiguration.java

@@ -79,7 +79,7 @@ public GenericContainer minio(MinioWaitStrategy minioWaitStrategy,
                         .withEnv("MINIO_WORM", properties.worm)
                         .withEnv("MINIO_BROWSER", properties.browser)
                         .withCommand("server", properties.directory)
-                        .withCreateContainerCmdModifier(cmd -> cmd.withCapAdd(Capability.NET_ADMIN))
+                        .withCreateContainerCmdModifier(cmd -> cmd.getHostConfig().withCapAdd(Capability.NET_ADMIN))
                         .waitingFor(minioWaitStrategy)
                         .withStartupTimeout(properties.getTimeoutDuration())
                         .withReuse(properties.isReuseContainer());

embedded-mongodb/src/main/java/com/playtika/test/mongodb/EmbeddedMongodbBootstrapConfiguration.java

@@ -65,7 +65,7 @@ public GenericContainer mongodb(
                         .withEnv("MONGO_INITDB_DATABASE", properties.getDatabase())
                         .withLogConsumer(containerLogsConsumer(log))
                         .withExposedPorts(properties.getPort())
-                        .withCreateContainerCmdModifier(cmd -> cmd.withCapAdd(Capability.NET_ADMIN))
+                        .withCreateContainerCmdModifier(cmd -> cmd.getHostConfig().withCapAdd(Capability.NET_ADMIN))
                         .waitingFor(mongodbStatusCheck)
                         .withStartupTimeout(properties.getTimeoutDuration())
                         .withReuse(properties.isReuseContainer());

embedded-mysql/src/main/java/com/playtika/test/mysql/EmbeddedMySQLBootstrapConfiguration.java

@@ -65,7 +65,7 @@ public MySQLContainer mysql(ConfigurableEnvironment environment,
                                 "--collation-server=" + properties.getCollation())
                         .withLogConsumer(containerLogsConsumer(log))
                         .withExposedPorts(properties.port)
-                        .withCreateContainerCmdModifier(cmd -> cmd.withCapAdd(Capability.NET_ADMIN))
+                        .withCreateContainerCmdModifier(cmd -> cmd.getHostConfig().withCapAdd(Capability.NET_ADMIN))
                         .withStartupTimeout(properties.getTimeoutDuration())
                         .withInitScript(properties.initScriptPath)
                         .withReuse(properties.isReuseContainer());

embedded-neo4j/src/main/java/com/playtika/test/neo4j/EmbeddedNeo4jBootstrapConfiguration.java

@@ -59,7 +59,7 @@ public Neo4jContainer neo4j(ConfigurableEnvironment environment,
         Neo4jContainer neo4j = new Neo4jContainer<>(properties.dockerImage)
                 .withAdminPassword(properties.password)
                 .withLogConsumer(containerLogsConsumer(log))
-                .withCreateContainerCmdModifier(cmd -> cmd.withCapAdd(Capability.NET_ADMIN))
+                .withCreateContainerCmdModifier(cmd -> cmd.getHostConfig().withCapAdd(Capability.NET_ADMIN))
                 .withStartupTimeout(properties.getTimeoutDuration())
                 .withReuse(properties.isReuseContainer());
         neo4j.start();

embedded-postgresql/src/main/java/com/playtika/test/postgresql/EmbeddedPostgreSQLBootstrapConfiguration.java

@@ -34,6 +34,7 @@
 import org.springframework.core.env.ConfigurableEnvironment;
 import org.springframework.core.env.MapPropertySource;
 import org.testcontainers.containers.PostgreSQLContainer;
+import org.testcontainers.utility.DockerImageName;
 
 import java.util.LinkedHashMap;
 
@@ -54,7 +55,8 @@ public ConcretePostgreSQLContainer postgresql(ConfigurableEnvironment environmen
         log.info("Starting postgresql server. Docker image: {}", properties.dockerImage);
 
         ConcretePostgreSQLContainer postgresql =
-                new ConcretePostgreSQLContainer(properties.dockerImage)
+                new ConcretePostgreSQLContainer(DockerImageName.parse(properties.dockerImage)
+                        .asCompatibleSubstituteFor("postgres"))
                         .withUsername(properties.getUser())
                         .withPassword(properties.getPassword())
                         .withDatabaseName(properties.getDatabase())
@@ -89,7 +91,7 @@ private void registerPostgresqlEnvironment(ConcretePostgreSQLContainer postgresq
     }
 
     private static class ConcretePostgreSQLContainer extends PostgreSQLContainer<ConcretePostgreSQLContainer> {
-        public ConcretePostgreSQLContainer(String dockerImageName) {
+        public ConcretePostgreSQLContainer(DockerImageName dockerImageName) {
             super(dockerImageName);
         }
     }

embedded-redis/src/main/java/com/playtika/test/redis/EmbeddedRedisBootstrapConfiguration.java

@@ -92,7 +92,7 @@ public GenericContainer redis(ConfigurableEnvironment environment,
 
         // CLUSTER SLOTS command returns IP:port for each node, so ports outside and inside
         // container must be the same
-        Consumer<CreateContainerCmd> containerCmdModifier = cmd -> cmd.withCapAdd(Capability.NET_ADMIN);
+        Consumer<CreateContainerCmd> containerCmdModifier = cmd -> cmd.getHostConfig().withCapAdd(Capability.NET_ADMIN);
         GenericContainer redis =
                 new FixedHostPortGenericContainer(properties.dockerImage)
                         .withFixedExposedPort(properties.port, properties.port)

pom.xml

@@ -61,7 +61,7 @@
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
         <java.version>1.8</java.version>
 
-        <testcontainers.version>1.14.3</testcontainers.version>
+        <testcontainers.version>1.15.0-rc2</testcontainers.version>
         <spring.cloud.version>Hoxton.SR8</spring.cloud.version>
 
         <equalsverifier.version>3.4.2</equalsverifier.version>

testcontainers-common/src/main/java/com/playtika/test/common/checks/AbstractCommandWaitStrategy.java

@@ -1,33 +1,34 @@
 /*
-* The MIT License (MIT)
-*
-* Copyright (c) 2018 Playtika
-*
-* Permission is hereby granted, free of charge, to any person obtaining a copy
-* of this software and associated documentation files (the "Software"), to deal
-* in the Software without restriction, including without limitation the rights
-* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-* copies of the Software, and to permit persons to whom the Software is
-* furnished to do so, subject to the following conditions:
-*
-* The above copyright notice and this permission notice shall be included in all
-* copies or substantial portions of the Software.
-*
-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-* SOFTWARE.
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Playtika
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
  */
 package com.playtika.test.common.checks;
 
-import com.playtika.test.common.utils.ContainerUtils;
 import lombok.extern.slf4j.Slf4j;
-import org.testcontainers.DockerClientFactory;
+import org.testcontainers.containers.Container;
 
-import static com.playtika.test.common.utils.ContainerUtils.ExecCmdResult;
+import java.util.Arrays;
+
+import static com.playtika.test.common.utils.ContainerUtils.executeInContainer;
 
 @Slf4j
 public abstract class AbstractCommandWaitStrategy extends AbstractRetryingWaitStrategy {
@@ -36,14 +37,14 @@ public abstract class AbstractCommandWaitStrategy extends AbstractRetryingWaitSt
 
     protected boolean isReady() {
         String commandName = getContainerType();
+
         String containerId = waitStrategyTarget.getContainerId();
-        log.debug("{} execution of command {} for container id: {} ", commandName, containerId);
+        String[] checkCommand = getCheckCommand();
+        log.debug("{} execution of command {} for container id: {} ", commandName, Arrays.toString(checkCommand), containerId);
 
-        ExecCmdResult healthCheckCmdResult =
-                ContainerUtils.execCmd(DockerClientFactory.instance().client(), containerId, getCheckCommand());
+        Container.ExecResult healthCheckCmdResult = executeInContainer(waitStrategyTarget, checkCommand);
 
-        log.debug("{} executed with exitCode: {}, output: {}",
-                commandName, healthCheckCmdResult.getExitCode(), healthCheckCmdResult.getOutput());
+        log.debug("{} executed with result: {}", commandName, healthCheckCmdResult);
 
         if (healthCheckCmdResult.getExitCode() != 0) {
             log.debug("{} executed with exitCode !=0, considering status as unknown", commandName);