Add TemporaryNetwork Rule

Author: kcooney

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

@@ -7,6 +7,7 @@
 import org.testcontainers.DockerClientFactory;
 import org.testcontainers.TestImages;
 import org.testcontainers.junit.vintage.Container;
+import org.testcontainers.junit.vintage.TemporaryNetwork;
 import org.testcontainers.junit.vintage.Testcontainers;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -17,7 +18,7 @@ public class NetworkTest {
     public static class WithRules {
 
         @Rule
-        public Network network = Network.newNetwork();
+        public TemporaryNetwork network = new TemporaryNetwork(Network.newNetwork());
 
         @Rule
         public Testcontainers containers = new Testcontainers(this);

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

@@ -0,0 +1,66 @@
+package org.testcontainers.junit.vintage;
+
+import org.junit.rules.ExternalResource;
+import org.testcontainers.containers.Network;
+
+/**
+ * Integrates {@link Network} with the JUnit4 lifecycle.
+ */
+public final class TemporaryNetwork extends ExternalResource implements Network {
+
+    private final Network network;
+
+    private volatile State state = State.BEFORE_RULE;
+
+    /**
+     * Creates an instance.
+     *
+     * <p>The passed-in network will be closed when the current test completes.
+     *
+     * @param network Network that the rule will delegate to.
+     */
+    public TemporaryNetwork(Network network) {
+        this.network = network;
+    }
+
+    @Override
+    public String getId() {
+        if (state == State.AFTER_RULE) {
+            throw new IllegalStateException("Cannot reference the network after the test completes");
+        }
+        return network.getId();
+    }
+
+    @Override
+    public void close() {
+        switch (state) {
+            case BEFORE_RULE:
+                throw new IllegalStateException("Cannot close the network before the test starts");
+            case INSIDE_RULE:
+                break;
+            case AFTER_RULE:
+                throw new IllegalStateException("Cannot reference the network after the test completes");
+        }
+        network.close();
+    }
+
+    @Override
+    protected void before() throws Throwable {
+        state = State.AFTER_RULE; // Just in case an exception is thrown below.
+        network.getId(); // This has the side-effect of creating the network.
+
+        state = State.INSIDE_RULE;
+    }
+
+    @Override
+    protected void after() {
+        state = State.AFTER_RULE;
+        network.close();
+    }
+
+    private enum State {
+        BEFORE_RULE,
+        INSIDE_RULE,
+        AFTER_RULE,
+    }
+}

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

@@ -119,21 +119,21 @@ private List<Startable> findContainers(Description description) {
         if (description.getTestClass() == null) {
             return Collections.emptyList();
         }
-        Predicate<Field> isTargetedContainer = isContainer();
+        Predicate<Field> isTargetedContainerField = isContainerField();
         if (testInstance == null) {
-            isTargetedContainer = isTargetedContainer.and(ModifierSupport::isStatic);
+            isTargetedContainerField = isTargetedContainerField.and(ModifierSupport::isStatic);
         } else {
-            isTargetedContainer = isTargetedContainer.and(ModifierSupport::isNotStatic);
+            isTargetedContainerField = isTargetedContainerField.and(ModifierSupport::isNotStatic);
         }
 
         return ReflectionSupport
-            .findFields(description.getTestClass(), isTargetedContainer, HierarchyTraversalMode.TOP_DOWN)
+            .findFields(description.getTestClass(), isTargetedContainerField, HierarchyTraversalMode.TOP_DOWN)
             .stream()
             .map(this::getContainerInstance)
             .collect(Collectors.toList());
     }
 
-    private static Predicate<Field> isContainer() {
+    private static Predicate<Field> isContainerField() {
         return field -> {
             boolean isAnnotatedWithContainer = AnnotationSupport.isAnnotated(field, Container.class);
             if (isAnnotatedWithContainer) {