Call TestRule @rules for outer classes.

Author: avh4

src/main/java/net/avh4/test/junit/InnerSpecMethodRunner.java

@@ -2,8 +2,11 @@
 
 import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.internal.runners.statements.RunAfters;
 import org.junit.internal.runners.statements.RunBefores;
+import org.junit.rules.RunRules;
+import org.junit.rules.TestRule;
 import org.junit.runner.notification.RunNotifier;
 import org.junit.runners.BlockJUnit4ClassRunner;
 import org.junit.runners.model.FrameworkMethod;
@@ -61,10 +64,23 @@ protected Statement methodBlock(FrameworkMethod method) {
         }
         statement = withOuterBefores(statement, outerInstance);
         statement = withOuterAfters(statement, outerInstance);
+        statement = withOuterRules(statement, outerInstance);
 
         return statement;
     }
 
+    private Statement withOuterRules(Statement statement,
+                                     Object outerInstance) {
+        List<TestRule> fieldRules = new TestClass(outerInstance.getClass())
+                .getAnnotatedFieldValues(outerInstance, Rule.class,
+                        TestRule.class);
+        if (!fieldRules.isEmpty()) {
+            statement = new RunRules(statement, fieldRules, null);
+            // TODO find an example where the Rule needs a Description
+        }
+        return statement;
+    }
+
     private Statement withOuterAfters(Statement statement,
                                       Object outerInstance) {
         final List<FrameworkMethod> outerAfters =

src/test/java/net/avh4/test/junit/InnerSpecMethodRunnerTest.java

@@ -2,10 +2,13 @@
 
 import net.avh4.test.junit.test.support.FailingTestExample;
 import net.avh4.test.junit.test.support.PassingTestExample;
+import org.hamcrest.Matchers;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.Runner;
 
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
 public class InnerSpecMethodRunnerTest extends RunnerTestBase {
@@ -76,4 +79,32 @@ public void shouldCallOuterAfterMethodsAfterInnerAfterMethods()
         assertTrue(
                 PassingTestExample.valueOf_innerAfterWasCalled_whenOuterAfterWasCalled);
     }
+
+    @Test
+    public void shouldCallInnerRules() throws Exception {
+        PassingTestExample.innerRuleCounter.reset();
+        runner.run(notifier);
+
+        assertThat(PassingTestExample.innerRuleCounter.count(),
+                Matchers.greaterThan(0));
+    }
+
+    @Test
+    public void shouldCallOuterRules() throws Exception {
+        PassingTestExample.outerRuleCounter.reset();
+        runner.run(notifier);
+
+        assertThat(PassingTestExample.outerRuleCounter.count(),
+                Matchers.greaterThan(0));
+    }
+
+    @Test
+    public void shouldCallOuterRulesAroundInnerRules() throws Exception {
+        runner.run(notifier);
+
+        int change =
+                PassingTestExample.valueOf_innerRuleCounter_whenOuterRuleEnded -
+                        PassingTestExample.valueOf_innerRuleCounter_whenOuterRuleStarted;
+        assertThat(change, is(1));
+    }
 }

src/test/java/net/avh4/test/junit/test/support/Counter.java

@@ -0,0 +1,17 @@
+package net.avh4.test.junit.test.support;
+
+public class Counter {
+    private int count;
+
+    public void reset() {
+        count = 0;
+    }
+
+    public void increment() {
+        count++;
+    }
+
+    public int count() {
+        return count;
+    }
+}

src/test/java/net/avh4/test/junit/test/support/IncrementWhenCalled.java

@@ -0,0 +1,24 @@
+package net.avh4.test.junit.test.support;
+
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+class IncrementWhenCalled implements TestRule {
+    private final Counter counter;
+
+    IncrementWhenCalled(Counter counter) {
+        this.counter = counter;
+    }
+
+    @Override
+    public Statement apply(final Statement base, Description description) {
+        return new Statement() {
+            @Override
+            public void evaluate() throws Throwable {
+                counter.increment();
+                base.evaluate();
+            }
+        };
+    }
+}

src/test/java/net/avh4/test/junit/test/support/PassingTestExample.java

@@ -1,9 +1,9 @@
 package net.avh4.test.junit.test.support;
 
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.*;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
 
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
@@ -13,6 +13,29 @@ public class PassingTestExample {
     public static boolean outerAfterWasCalled;
     public static boolean innerAfterWasCalled;
     public static boolean valueOf_innerAfterWasCalled_whenOuterAfterWasCalled;
+    public static Counter innerRuleCounter = new Counter();
+    public static Counter outerRuleCounter = new Counter();
+    public static int valueOf_innerRuleCounter_whenOuterRuleStarted;
+    public static int valueOf_innerRuleCounter_whenOuterRuleEnded;
+
+    @Rule
+    public TestRule outerRule = new IncrementWhenCalled(outerRuleCounter);
+    @Rule
+    public TestRule checkInnerRuleState = new TestRule() {
+        @Override
+        public Statement apply(final Statement base, Description description) {
+            return new Statement() {
+                @Override
+                public void evaluate() throws Throwable {
+                    valueOf_innerRuleCounter_whenOuterRuleStarted =
+                            innerRuleCounter.count();
+                    base.evaluate();
+                    valueOf_innerRuleCounter_whenOuterRuleEnded =
+                            innerRuleCounter.count();
+                }
+            };
+        }
+    };
 
     @Before
     public void setup() throws Exception {
@@ -31,6 +54,9 @@ public class Inner1 {
         private boolean innerSetupWasCalled;
         private boolean valueOf_outerSetupWasCalled_whenInnerSetupWasCalled;
 
+        @Rule
+        public TestRule innerRule = new IncrementWhenCalled(innerRuleCounter);
+
         @Before
         public void setup() throws Exception {
             innerSetupWasCalled = true;
@@ -69,6 +95,7 @@ public void passesUnlessInnerBeforesWereCalledBeforeOuterBefores()
         public void ignored() throws Exception {
             fail();
         }
+
     }
 
     public class Inner2 {
@@ -83,4 +110,5 @@ public void test2_1() throws Exception {
     public void test_1() throws Exception {
         //pass
     }
+
 }