@IgnoreUntil annotation can now be on a method only.

@IgnoreUntil method annotation overrides class annotation when non-default value set. Fixes issue unruly#3
siladu · Feb 18, 2018 · ee34f7d · ee34f7d
1 parent 953f34d
commit ee34f7d
Show file tree

Hide file tree

Showing 2 changed files with 55 additions and 1 deletion.
diff --git a/src/main/java/co/unruly/junit/IgnoreUntilRule.java b/src/main/java/co/unruly/junit/IgnoreUntilRule.java
@@ -10,12 +10,14 @@
 
 public class IgnoreUntilRule implements TestRule {
 
+    static final String DEFAULT_IGNORE = "2000-01-01";
+
     @Override
     public Statement apply(Statement base, Description description) {
 
         IgnoreUntil ignoreUntil = description.getAnnotation(IgnoreUntil.class);
 
-        if (ignoreUntil != null && description.getTestClass() != null) {
+        if (ignoreUntil != null && ignoreUntil.value().equals(DEFAULT_IGNORE) && description.getTestClass() != null) {
             ignoreUntil = description.getTestClass().getAnnotation(IgnoreUntil.class);
         }
 

diff --git a/src/test/java/co/unruly/junit/IgnoreUntilRuleTest.java b/src/test/java/co/unruly/junit/IgnoreUntilRuleTest.java
@@ -10,6 +10,8 @@
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
 
+import java.lang.annotation.Annotation;
+
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.when;
@@ -50,4 +52,54 @@ public void shouldReturnAlwaysPassesStatementIfIgnoreUntilDateIsInTheFuture() {
 
         assertTrue(rule.apply(mockStatement, mockDescription) instanceof IgnoreUntilRule.AlwaysPassesStatement);
     }
+
+    @Test
+    public void shouldReturnOriginalStatementIfMethodAnnotationWithNonDefaultValueExists() throws NoSuchMethodException {
+        Annotation[] methodAnnotations = (MethodOverrideClassAnnotationTest.class).getMethod("shouldNowExecute").getDeclaredAnnotations();
+        Description testMethodDescription = Description.createTestDescription(MethodOverrideClassAnnotationTest.class, "shouldNowExecute", methodAnnotations);
+        assertEquals(2, testMethodDescription.getAnnotations().size());
+
+        assertEquals(mockStatement, rule.apply(mockStatement, testMethodDescription));
+    }
+
+    @IgnoreUntil("2099-01-01")
+    static class MethodOverrideClassAnnotationTest {
+
+        @IgnoreUntil("2018-01-01")
+        @Test
+        public void shouldNowExecute() { }
+    }
+
+    @Test
+    public void shouldReturnAlwaysPassesIfMethodAnnotationInheritsFromClassAnnotation() throws NoSuchMethodException {
+        Annotation[] methodAnnotations = (MethodInheritFromClassAnnotationTest.class).getMethod("shouldNowExecute").getDeclaredAnnotations();
+        Description testMethodDescription = Description.createTestDescription(MethodInheritFromClassAnnotationTest.class, "shouldNowExecute", methodAnnotations);
+        assertEquals(2, testMethodDescription.getAnnotations().size());
+
+        assertTrue(rule.apply(mockStatement, testMethodDescription) instanceof IgnoreUntilRule.AlwaysPassesStatement);
+    }
+
+    @IgnoreUntil("2099-01-01")
+    static class MethodInheritFromClassAnnotationTest {
+
+        @IgnoreUntil
+        @Test
+        public void shouldNowExecute() { }
+    }
+
+    @Test
+    public void shouldReturnAlwaysPassesIfOnlyMethodAnnotationExists() throws NoSuchMethodException {
+        Annotation[] methodAnnotations = (MethodAnnotationOnly.class).getMethod("shouldNowExecute").getDeclaredAnnotations();
+        Description testMethodDescription = Description.createTestDescription(MethodAnnotationOnly.class, "shouldNowExecute", methodAnnotations);
+        assertEquals(2, testMethodDescription.getAnnotations().size());
+
+        assertTrue(rule.apply(mockStatement, testMethodDescription) instanceof IgnoreUntilRule.AlwaysPassesStatement);
+    }
+
+    static class MethodAnnotationOnly {
+
+        @IgnoreUntil("2099-01-01")
+        @Test
+        public void shouldNowExecute() { }
+    }
 }