Support applying @container to methods

Author: kcooney

modules/junit-vintage/src/main/java/org/testcontainers/junit/vintage/Container.java

@@ -9,7 +9,7 @@
  * The {@code @Container} annotation marks containers that should be managed by the
  * {@code Testcontainers} rule.
  */
-@Target({ ElementType.FIELD, ElementType.ANNOTATION_TYPE })
+@Target({ ElementType.FIELD, ElementType.METHOD })
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Container {
 }

modules/junit-vintage/src/main/java/org/testcontainers/junit/vintage/Testcontainers.java

@@ -1,16 +1,21 @@
 package org.testcontainers.junit.vintage;
 
+import lombok.SneakyThrows;
 import org.junit.platform.commons.support.AnnotationSupport;
 import org.junit.platform.commons.support.HierarchyTraversalMode;
 import org.junit.platform.commons.support.ModifierSupport;
 import org.junit.platform.commons.support.ReflectionSupport;
 import org.junit.runner.Description;
+import org.junit.runners.model.FrameworkMethod;
 import org.junit.runners.model.MultipleFailureException;
 import org.testcontainers.lifecycle.Startable;
 import org.testcontainers.lifecycle.TestDescription;
 import org.testcontainers.lifecycle.TestLifecycleAware;
 
+import java.lang.reflect.AnnotatedElement;
 import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -20,12 +25,15 @@
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * Integrates Testcontainers with the JUnit4 lifecycle.
  */
 public final class Testcontainers extends FailureDetectingExternalResource {
 
+    private static HierarchyTraversalMode TRAVERSAL_MODE = HierarchyTraversalMode.TOP_DOWN;
+
     private final Object testInstance;
 
     private List<Startable> startedContainers = Collections.emptyList();
@@ -116,51 +124,76 @@ protected void finished(Description description) throws Exception {
     }
 
     private List<Startable> findContainers(Description description) {
-        if (description.getTestClass() == null) {
+        Class<?> testClass = description.getTestClass();
+        if (testClass == null) {
             return Collections.emptyList();
         }
-        Predicate<Field> isTargetedContainer = isContainer();
-        if (testInstance == null) {
-            isTargetedContainer = isTargetedContainer.and(ModifierSupport::isStatic);
-        } else {
-            isTargetedContainer = isTargetedContainer.and(ModifierSupport::isNotStatic);
-        }
 
-        return ReflectionSupport
-            .findFields(description.getTestClass(), isTargetedContainer, HierarchyTraversalMode.TOP_DOWN)
-            .stream()
-            .map(this::getContainerInstance)
+        Predicate<Member> hasExpectedModifier = testInstance == null
+            ? ModifierSupport::isStatic
+            : ModifierSupport::isNotStatic;
+
+        return Stream
+            .of(
+                ReflectionSupport
+                    .findMethods(testClass, isContainerMethod().and(hasExpectedModifier), TRAVERSAL_MODE)
+                    .stream()
+                    .map(this::createContainerInstance),
+                ReflectionSupport
+                    .findFields(testClass, isContainerField().and(hasExpectedModifier), TRAVERSAL_MODE)
+                    .stream()
+                    .map(this::getContainerInstance)
+            )
+            .flatMap(s -> s)
             .collect(Collectors.toList());
     }
 
-    private static Predicate<Field> isContainer() {
-        return field -> {
-            boolean isAnnotatedWithContainer = AnnotationSupport.isAnnotated(field, Container.class);
-            if (isAnnotatedWithContainer) {
-                boolean isStartable = Startable.class.isAssignableFrom(field.getType());
+    private static Predicate<Method> isContainerMethod() {
+        return method -> isAnnotatedWithContainer(method);
+    }
 
-                if (!isStartable) {
-                    throw new RuntimeException(
-                        String.format("The @Container field '%s' does not implement Startable", field.getName())
-                    );
-                }
-                return true;
-            }
-            return false;
-        };
+    private static Predicate<Field> isContainerField() {
+        return field -> isAnnotatedWithContainer(field);
     }
 
+    private static boolean isAnnotatedWithContainer(AnnotatedElement element) {
+        return AnnotationSupport.isAnnotated(element, Container.class);
+    }
+
+    private Startable createContainerInstance(Method method) {
+        if (!Startable.class.isAssignableFrom(method.getReturnType())) {
+            throw new RuntimeException(
+                String.format("The @Container method '%s()' does not return a Startable", method.getName())
+            );
+        }
+
+        method.setAccessible(true);
+        Object container = invokeExplosively(method, testInstance);
+        if (container == null) {
+            throw new RuntimeException(String.format("The @Container method '%s()' returned null", method.getName()));
+        }
+        return (Startable) container;
+    }
+
+    @SneakyThrows(IllegalAccessException.class)
     private Startable getContainerInstance(Field field) {
-        try {
-            field.setAccessible(true);
-            Startable containerInstance = (Startable) field.get(testInstance);
-            if (containerInstance == null) {
-                throw new RuntimeException("Container " + field.getName() + " needs to be initialized");
-            }
-            return containerInstance;
-        } catch (IllegalAccessException e) {
-            throw new RuntimeException("Cannot access container defined in field " + field.getName());
+        if (!Startable.class.isAssignableFrom(field.getType())) {
+            throw new RuntimeException(
+                String.format("The @Container field '%s' does not implement Startable", field.getName())
+            );
         }
+
+        field.setAccessible(true);
+        Startable container = (Startable) field.get(testInstance);
+        if (container == null) {
+            throw new RuntimeException("Container " + field.getName() + " needs to be initialized");
+        }
+        return container;
+    }
+
+    @SneakyThrows(Throwable.class)
+    private static Object invokeExplosively(Method method, Object target, final Object... params) {
+        return new FrameworkMethod(method).invokeExplosively(target, params);
     }
 
     private static <T> void forEachReversed(List<T> list, Consumer<? super T> callback) {

modules/junit-vintage/src/test/java/org/testcontainers/junit/vintage/TestcontainersTest.java

@@ -171,9 +171,13 @@ static void reset() {
         @Container
         private final TestLifecycleAwareContainerMock testContainer1 = new TestLifecycleAwareContainerMock();
 
-        @Container
         private final TestLifecycleAwareContainerMock testContainer2 = new TestLifecycleAwareContainerMock();
 
+        @Container
+        private TestLifecycleAwareContainerMock createContainer() {
+            return testContainer2;
+        }
+
         @Test
         public void containerStarted() {
             testsStarted++;