Add named container lookup to support multiple containers of the same type

Adds a name attribute to @TestContainer so that containers can be registered and looked up by name, allowing multiple containers of the same type to coexist in a single test class.

Part of #117

Signed-off-by: Radoslav Husar <rhusar@redhat.com>
Signed-off-by: Radoslav Husar <radosoft@gmail.com>

Author: rhusar

pom.xml

@@ -57,6 +57,13 @@
             <organization>Red Hat, Inc.</organization>
             <organizationUrl>https://redhat.com</organizationUrl>
         </developer>
+        <developer>
+            <id>rhusar</id>
+            <name>Radoslav Husar</name>
+            <email>rhusar@redhat.com</email>
+            <organization>Red Hat, Inc.</organization>
+            <organizationUrl>https://redhat.com</organizationUrl>
+        </developer>
     </developers>
 
     <scm>

src/main/java/org/arquillian/testcontainers/TestcontainerDescription.java

@@ -19,13 +19,20 @@ class TestcontainerDescription {
      * The annotation that was on the field
      */
     final Testcontainer testcontainer;
+
+    /**
+     * The name of the container, or an empty string for unnamed containers
+     */
+    final String name;
+
     /**
      * The instance of the container created
      */
     final GenericContainer<?> instance;
 
     TestcontainerDescription(final Testcontainer testcontainer, final GenericContainer<?> instance) {
         this.testcontainer = testcontainer;
+        this.name = testcontainer.name();
         this.instance = instance;
     }
 }

src/main/java/org/arquillian/testcontainers/TestcontainerRegistry.java

@@ -37,19 +37,45 @@ class TestcontainerRegistry implements Iterable<TestcontainerDescription> {
      */
     GenericContainer<?> lookupOrCreate(final Class<GenericContainer<?>> type, final Testcontainer testcontainer,
             final List<Annotation> qualifiers) {
-        GenericContainer<?> result = lookup(type, qualifiers);
+        final String name = testcontainer.name();
+        GenericContainer<?> result = name.isEmpty() ? lookup(type, qualifiers) : lookup(name);
         if (result == null) {
             try {
                 final Constructor<? extends GenericContainer<?>> constructor = getConstructor(type, testcontainer);
                 result = constructor.newInstance();
-                this.containers.add(new TestcontainerDescription(testcontainer, result));
+                final TestcontainerDescription description = new TestcontainerDescription(testcontainer, result);
+                if (!name.isEmpty()) {
+                    for (TestcontainerDescription containerDesc : this.containers) {
+                        if (name.equals(containerDesc.name)) {
+                            throw new IllegalArgumentException(
+                                    String.format("A container with name \"%s\" is already registered", name));
+                        }
+                    }
+                }
+                this.containers.add(description);
             } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
                 throw new IllegalArgumentException(String.format("Could create container %s", type.getName()), e);
             }
         }
         return result;
     }
 
+    /**
+     * Lookup a container by name.
+     *
+     * @param name the container name
+     *
+     * @return the container instance or {@code null} if not found
+     */
+    GenericContainer<?> lookup(final String name) {
+        for (TestcontainerDescription containerDesc : this.containers) {
+            if (name.equals(containerDesc.name)) {
+                return containerDesc.instance;
+            }
+        }
+        return null;
+    }
+
     /**
      * Lookup the container in the test container instances. If more than one container is found for the type or
      * qualifier, an {@link IllegalArgumentException} is thrown.
@@ -63,14 +89,14 @@ GenericContainer<?> lookup(final Class<?> type, final List<Annotation> qualifier
         final List<TestcontainerDescription> foundContainers = new ArrayList<>();
         if (qualifiers.isEmpty()) {
             for (TestcontainerDescription containerDesc : this.containers) {
-                if (type.isAssignableFrom(containerDesc.instance.getClass())) {
+                if (containerDesc.name.isEmpty() && type.isAssignableFrom(containerDesc.instance.getClass())) {
                     foundContainers.add(containerDesc);
                 }
             }
         } else {
             for (TestcontainerDescription containerDesc : this.containers) {
                 for (Annotation qualifier : qualifiers) {
-                    if (type.isAssignableFrom(containerDesc.instance.getClass())
+                    if (containerDesc.name.isEmpty() && type.isAssignableFrom(containerDesc.instance.getClass())
                             && type.isAnnotationPresent(qualifier.annotationType())) {
                         foundContainers.add(containerDesc);
                     }

src/main/java/org/arquillian/testcontainers/api/Testcontainer.java

@@ -55,6 +55,17 @@
      */
     boolean value() default true;
 
+    /**
+     * An optional name for the container. When set, the container is registered and looked up by this name, allowing
+     * multiple containers of the same type to coexist in a single test class.
+     * <p>
+     * If left as the default empty string, the container is looked up by type and qualifiers as usual.
+     * </p>
+     *
+     * @return the name of the container, or an empty string for unnamed containers
+     */
+    String name() default "";
+
     /**
      * The type used to create the value for the field. The type must have a no-arg constructor.
      * <p>

src/test/java/org/arquillian/testcontainers/NamedContainerTest.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright The Arquillian Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.arquillian.testcontainers;
+
+import org.arquillian.testcontainers.api.Testcontainer;
+import org.arquillian.testcontainers.api.TestcontainersRequired;
+import org.arquillian.testcontainers.common.SimpleTestContainer;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.container.test.api.RunAsClient;
+import org.jboss.arquillian.junit5.ArquillianExtension;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.opentest4j.TestAbortedException;
+
+@ExtendWith(ArquillianExtension.class)
+@TestcontainersRequired(TestAbortedException.class)
+@RunAsClient
+public class NamedContainerTest {
+
+    @Deployment
+    public static JavaArchive createDeployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+                .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+    @Testcontainer(name = "first")
+    private SimpleTestContainer first;
+
+    @Testcontainer(name = "second")
+    private SimpleTestContainer second;
+
+    @Testcontainer
+    private SimpleTestContainer unnamed;
+
+    @Test
+    public void checkAllInjected() {
+        Assertions.assertNotNull(first, "Expected the first container to be injected.");
+        Assertions.assertNotNull(second, "Expected the second container to be injected.");
+        Assertions.assertNotNull(unnamed, "Expected the unnamed container to be injected.");
+    }
+
+    @Test
+    public void checkAllRunning() {
+        Assertions.assertTrue(first.isRunning(), "Expected the first container to be running.");
+        Assertions.assertTrue(second.isRunning(), "Expected the second container to be running.");
+        Assertions.assertTrue(unnamed.isRunning(), "Expected the unnamed container to be running.");
+    }
+
+    @Test
+    public void checkAllDifferentInstances() {
+        Assertions.assertNotSame(first, second, "Expected named containers to be different instances.");
+        Assertions.assertNotSame(first, unnamed, "Expected named and unnamed containers to be different instances.");
+        Assertions.assertNotSame(second, unnamed, "Expected named and unnamed containers to be different instances.");
+    }
+}