In contrast to the {@link org.springframework.test.context.junit4.SpringJUnit4ClassRunner * SpringJUnit4ClassRunner}, Spring's rule-based JUnit support has the advantage * that it is independent of any {@link org.junit.runner.Runner Runner} and * can therefore be combined with existing alternative runners like JUnit's * {@code Parameterized} or third-party runners such as the {@code MockitoJUnitRunner}. * *
In order to achieve the same functionality as the {@code SpringJUnit4ClassRunner}, * however, a {@code SpringMethodRule} must be combined with a {@link SpringClassRule}, * since {@code SpringMethodRule} only supports the instance-level and method-level * features of the {@code SpringJUnit4ClassRunner}. * *
public class ExampleSpringIntegrationTest {
*
* @ClassRule
* public static final SpringClassRule SPRING_CLASS_RULE = new SpringClassRule();
*
* @Rule
* public final SpringMethodRule springMethodRule = new SpringMethodRule();
*
* // ...
* }The following list constitutes all annotations currently supported directly * or indirectly by {@code SpringMethodRule}. (Note that additional annotations * may be supported by various * {@link org.springframework.test.context.TestExecutionListener TestExecutionListener} or * {@link org.springframework.test.context.TestContextBootstrapper TestContextBootstrapper} * implementations.) * *
NOTE: As of Spring Framework 4.3, this class requires JUnit 4.12 or higher. * *
WARNING: Due to the shortcomings of JUnit rules, the * {@code SpringMethodRule} does not support the * {@code beforeTestExecution()} and {@code afterTestExecution()} callbacks of the * {@link org.springframework.test.context.TestExecutionListener TestExecutionListener} * API. * * @author Sam Brannen * @author Philippe Marschall * @since 4.2 * @see #apply(Statement, FrameworkMethod, Object) * @see SpringClassRule * @see org.springframework.test.context.TestContextManager * @see org.springframework.test.context.junit4.SpringJUnit4ClassRunner */ public class SpringMethodRule implements MethodRule { private static final Log logger = LogFactory.getLog(SpringMethodRule.class); static { if (!ClassUtils.isPresent("org.junit.internal.Throwables", SpringMethodRule.class.getClassLoader())) { throw new IllegalStateException("SpringMethodRule requires JUnit 4.12 or higher."); } } /** * Apply instance-level and method-level features of * the Spring TestContext Framework to the supplied {@code base} * statement. *
Specifically, this method invokes the * {@link TestContextManager#prepareTestInstance prepareTestInstance()}, * {@link TestContextManager#beforeTestMethod beforeTestMethod()}, and * {@link TestContextManager#afterTestMethod afterTestMethod()} methods * on the {@code TestContextManager}, potentially with Spring timeouts * and repetitions. *
In addition, this method checks whether the test is enabled in * the current execution environment. This prevents methods with a * non-matching {@code @IfProfileValue} annotation from running altogether, * even skipping the execution of {@code prepareTestInstance()} methods * in {@code TestExecutionListeners}. * @param base the base {@code Statement} that this rule should be applied to * @param frameworkMethod the method which is about to be invoked on the test instance * @param testInstance the current test instance * @return a statement that wraps the supplied {@code base} with instance-level * and method-level features of the Spring TestContext Framework * @see #withBeforeTestMethodCallbacks * @see #withAfterTestMethodCallbacks * @see #withPotentialRepeat * @see #withPotentialTimeout * @see #withTestInstancePreparation * @see #withProfileValueCheck */ @Override public Statement apply(Statement base, FrameworkMethod frameworkMethod, Object testInstance) { if (logger.isDebugEnabled()) { logger.debug("Applying SpringMethodRule to test method [" + frameworkMethod.getMethod() + "]"); } Class testClass = testInstance.getClass(); validateSpringClassRuleConfiguration(testClass); TestContextManager testContextManager = SpringClassRule.getTestContextManager(testClass); Statement statement = base; statement = withBeforeTestMethodCallbacks(statement, frameworkMethod, testInstance, testContextManager); statement = withAfterTestMethodCallbacks(statement, frameworkMethod, testInstance, testContextManager); statement = withTestInstancePreparation(statement, testInstance, testContextManager); statement = withPotentialRepeat(statement, frameworkMethod, testInstance); statement = withPotentialTimeout(statement, frameworkMethod, testInstance); statement = withProfileValueCheck(statement, frameworkMethod, testInstance); return statement; } /** * Wrap the supplied {@link Statement} with a {@code RunBeforeTestMethodCallbacks} statement. * @see RunBeforeTestMethodCallbacks */ private Statement withBeforeTestMethodCallbacks(Statement statement, FrameworkMethod frameworkMethod, Object testInstance, TestContextManager testContextManager) { return new RunBeforeTestMethodCallbacks( statement, testInstance, frameworkMethod.getMethod(), testContextManager); } /** * Wrap the supplied {@link Statement} with a {@code RunAfterTestMethodCallbacks} statement. * @see RunAfterTestMethodCallbacks */ private Statement withAfterTestMethodCallbacks(Statement statement, FrameworkMethod frameworkMethod, Object testInstance, TestContextManager testContextManager) { return new RunAfterTestMethodCallbacks( statement, testInstance, frameworkMethod.getMethod(), testContextManager); } /** * Wrap the supplied {@link Statement} with a {@code RunPrepareTestInstanceCallbacks} statement. * @see RunPrepareTestInstanceCallbacks */ private Statement withTestInstancePreparation(Statement statement, Object testInstance, TestContextManager testContextManager) { return new RunPrepareTestInstanceCallbacks(statement, testInstance, testContextManager); } /** * Wrap the supplied {@link Statement} with a {@code SpringRepeat} statement. *
Supports Spring's {@link org.springframework.test.annotation.Repeat @Repeat} * annotation. * @see SpringRepeat */ private Statement withPotentialRepeat(Statement next, FrameworkMethod frameworkMethod, Object testInstance) { return new SpringRepeat(next, frameworkMethod.getMethod()); } /** * Wrap the supplied {@link Statement} with a {@code SpringFailOnTimeout} statement. *
Supports Spring's {@link org.springframework.test.annotation.Timed @Timed} * annotation. * @see SpringFailOnTimeout */ private Statement withPotentialTimeout(Statement next, FrameworkMethod frameworkMethod, Object testInstance) { return new SpringFailOnTimeout(next, frameworkMethod.getMethod()); } /** * Wrap the supplied {@link Statement} with a {@code ProfileValueChecker} statement. * @see ProfileValueChecker */ private Statement withProfileValueCheck(Statement statement, FrameworkMethod frameworkMethod, Object testInstance) { return new ProfileValueChecker(statement, testInstance.getClass(), frameworkMethod.getMethod()); } /** * Throw an {@link IllegalStateException} if the supplied {@code testClass} * does not declare a {@code public static final SpringClassRule} field * that is annotated with {@code @ClassRule}. */ private static SpringClassRule validateSpringClassRuleConfiguration(Class testClass) { Field ruleField = null; for (Field field : testClass.getFields()) { if (ReflectionUtils.isPublicStaticFinal(field) && SpringClassRule.class.isAssignableFrom(field.getType())) { ruleField = field; break; } } if (ruleField == null) { throw new IllegalStateException(String.format( "Failed to find 'public static final SpringClassRule' field in test class [%s]. " + "Consult the javadoc for SpringClassRule for details.", testClass.getName())); } if (!ruleField.isAnnotationPresent(ClassRule.class)) { throw new IllegalStateException(String.format( "SpringClassRule field [%s] must be annotated with JUnit's @ClassRule annotation. " + "Consult the javadoc for SpringClassRule for details.", ruleField)); } return (SpringClassRule) ReflectionUtils.getField(ruleField, null); } }