org.springframework.test.context.junit4

Class SpringJUnit4ClassRunner

java.lang.Object

org.junit.runner.Runner

org.junit.runners.ParentRunner<FrameworkMethod>

org.junit.runners.BlockJUnit4ClassRunner

org.springframework.test.context.junit4.SpringJUnit4ClassRunner

All Implemented Interfaces:

Describable, Filterable, Sortable

Direct Known Subclasses:

SpringRunner

public class SpringJUnit4ClassRunner
extends BlockJUnit4ClassRunner

SpringJUnit4ClassRunner is a custom extension of JUnit's BlockJUnit4ClassRunner which provides functionality of the Spring TestContext Framework to standard JUnit tests by means of the TestContextManager and associated support classes and annotations.

To use this class, simply annotate a JUnit 4 based test class with @RunWith(SpringJUnit4ClassRunner.class) or @RunWith(SpringRunner.class).

The following list constitutes all annotations currently supported directly or indirectly by SpringJUnit4ClassRunner. (Note that additional annotations may be supported by various TestExecutionListener or TestContextBootstrapper implementations.)

• @Test(expected=...)
• @Test(timeout=...)
• @Timed
• @Repeat
• @Ignore
• @ProfileValueSourceConfiguration
• @IfProfileValue

If you would like to use the Spring TestContext Framework with a runner other than this one, use SpringClassRule and SpringMethodRule.

NOTE: As of Spring Framework 4.3, this class requires JUnit 4.12 or higher.

Since:

2.5

Author:

Sam Brannen, Juergen Hoeller

See Also:

SpringRunner, TestContextManager, AbstractJUnit4SpringContextTests, AbstractTransactionalJUnit4SpringContextTests, SpringClassRule, SpringMethodRule

Constructor Summary

Constructors

Constructor and Description
SpringJUnit4ClassRunner(java.lang.Class<?> clazz) Construct a new SpringJUnit4ClassRunner and initialize a TestContextManager to provide Spring testing functionality to standard JUnit tests.

Method Summary

Modifier and Type	Method and Description
protected java.lang.Object	createTest() Delegate to the parent implementation for creating the test instance and then allow the TestContextManager to prepare the test instance before returning it.
protected TestContextManager	createTestContextManager(java.lang.Class<?> clazz) Create a new TestContextManager for the supplied test class.
Description	getDescription() Return a description suitable for an ignored test class if the test is disabled via @IfProfileValue at the class-level, and otherwise delegate to the parent implementation.
protected java.lang.Class<? extends java.lang.Throwable>	getExpectedException(FrameworkMethod frameworkMethod) Get the exception that the supplied test method is expected to throw.
protected long	getJUnitTimeout(FrameworkMethod frameworkMethod) Retrieve the configured JUnit timeout from the @Test annotation on the supplied test method.
protected long	getSpringTimeout(FrameworkMethod frameworkMethod) Retrieve the configured Spring-specific timeout from the @Timed annotation on the supplied test method.
protected TestContextManager	getTestContextManager() Get the TestContextManager associated with this runner.
protected boolean	isTestMethodIgnored(FrameworkMethod frameworkMethod) Return true if @Ignore is present for the supplied test method or if the test method is disabled via @IfProfileValue.
protected Statement	methodBlock(FrameworkMethod frameworkMethod) Augment the default JUnit behavior with potential repeats of the entire execution chain.
protected Statement	possiblyExpectingExceptions(FrameworkMethod frameworkMethod, java.lang.Object testInstance, Statement next) Perform the same logic as BlockJUnit4ClassRunner.possiblyExpectingExceptions(FrameworkMethod, Object, Statement) except that the expected exception is retrieved using getExpectedException(FrameworkMethod).
void	run(RunNotifier notifier) Check whether the test is enabled in the current execution environment.
protected void	runChild(FrameworkMethod frameworkMethod, RunNotifier notifier) Perform the same logic as BlockJUnit4ClassRunner.runChild(FrameworkMethod, RunNotifier), except that tests are determined to be ignored by isTestMethodIgnored(FrameworkMethod).
protected Statement	withAfterClasses(Statement statement) Wrap the Statement returned by the parent implementation with a RunAfterTestClassCallbacks statement, thus preserving the default JUnit functionality while adding support for the Spring TestContext Framework.
protected Statement	withAfters(FrameworkMethod frameworkMethod, java.lang.Object testInstance, Statement statement) Wrap the Statement returned by the parent implementation with a RunAfterTestMethodCallbacks statement, thus preserving the default functionality while adding support for the Spring TestContext Framework.
protected Statement	withBeforeClasses(Statement statement) Wrap the Statement returned by the parent implementation with a RunBeforeTestClassCallbacks statement, thus preserving the default JUnit functionality while adding support for the Spring TestContext Framework.
protected Statement	withBefores(FrameworkMethod frameworkMethod, java.lang.Object testInstance, Statement statement) Wrap the Statement returned by the parent implementation with a RunBeforeTestMethodCallbacks statement, thus preserving the default functionality while adding support for the Spring TestContext Framework.
protected Statement	withPotentialRepeat(FrameworkMethod frameworkMethod, java.lang.Object testInstance, Statement next) Wrap the supplied Statement with a SpringRepeat statement.
protected Statement	withPotentialTimeout(FrameworkMethod frameworkMethod, java.lang.Object testInstance, Statement next) Perform the same logic as BlockJUnit4ClassRunner.withPotentialTimeout(FrameworkMethod, Object, Statement) but with additional support for Spring's @Timed annotation.

Methods inherited from class org.junit.runners.BlockJUnit4ClassRunner

collectInitializationErrors, computeTestMethods, describeChild, getChildren, getTestRules, isIgnored, methodInvoker, rules, testName, validateConstructor, validateFields, validateInstanceMethods, validateNoNonStaticInnerClass, validateOnlyOneConstructor, validateTestMethods, validateZeroArgConstructor

Methods inherited from class org.junit.runners.ParentRunner

childrenInvoker, classBlock, classRules, createTestClass, filter, getName, getRunnerAnnotations, getTestClass, runLeaf, setScheduler, sort, validatePublicVoidNoArgMethods

Methods inherited from class org.junit.runner.Runner

testCount

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SpringJUnit4ClassRunner

public SpringJUnit4ClassRunner(java.lang.Class<?> clazz)
                        throws InitializationError

Construct a new SpringJUnit4ClassRunner and initialize a TestContextManager to provide Spring testing functionality to standard JUnit tests.

Parameters:

clazz - the test class to be run

Throws:

InitializationError

See Also:

createTestContextManager(Class)

Method Detail

createTestContextManager

protected TestContextManager createTestContextManager(java.lang.Class<?> clazz)

Create a new TestContextManager for the supplied test class.

Can be overridden by subclasses.

Parameters:

clazz - the test class to be managed

getTestContextManager

protected final TestContextManager getTestContextManager()

Get the TestContextManager associated with this runner.

getDescription

public Description getDescription()

Return a description suitable for an ignored test class if the test is disabled via @IfProfileValue at the class-level, and otherwise delegate to the parent implementation.

Specified by:

getDescription in interface Describable

Overrides:

getDescription in class ParentRunner<FrameworkMethod>

See Also:

ProfileValueUtils.isTestEnabledInThisEnvironment(Class)

run

public void run(RunNotifier notifier)

Check whether the test is enabled in the current execution environment.

This prevents classes with a non-matching @IfProfileValue annotation from running altogether, even skipping the execution of prepareTestInstance() methods in TestExecutionListeners.

Overrides:

run in class ParentRunner<FrameworkMethod>

See Also:

ProfileValueUtils.isTestEnabledInThisEnvironment(Class), IfProfileValue, TestExecutionListener

withBeforeClasses

protected Statement withBeforeClasses(Statement statement)

Wrap the Statement returned by the parent implementation with a RunBeforeTestClassCallbacks statement, thus preserving the default JUnit functionality while adding support for the Spring TestContext Framework.

Overrides:

withBeforeClasses in class ParentRunner<FrameworkMethod>

See Also:

RunBeforeTestClassCallbacks

withAfterClasses

protected Statement withAfterClasses(Statement statement)

Wrap the Statement returned by the parent implementation with a RunAfterTestClassCallbacks statement, thus preserving the default JUnit functionality while adding support for the Spring TestContext Framework.

Overrides:

withAfterClasses in class ParentRunner<FrameworkMethod>

See Also:

RunAfterTestClassCallbacks

createTest

protected java.lang.Object createTest()
                               throws java.lang.Exception

Delegate to the parent implementation for creating the test instance and then allow the TestContextManager to prepare the test instance before returning it.

Overrides:

createTest in class BlockJUnit4ClassRunner

Throws:

java.lang.Exception

See Also:

TestContextManager.prepareTestInstance(java.lang.Object)

runChild

protected void runChild(FrameworkMethod frameworkMethod,
                        RunNotifier notifier)

Perform the same logic as BlockJUnit4ClassRunner.runChild(FrameworkMethod, RunNotifier), except that tests are determined to be ignored by isTestMethodIgnored(FrameworkMethod).

Overrides:

runChild in class BlockJUnit4ClassRunner

methodBlock

protected Statement methodBlock(FrameworkMethod frameworkMethod)

Augment the default JUnit behavior with potential repeats of the entire execution chain.

Furthermore, support for timeouts has been moved down the execution chain in order to include execution of @Before and @After methods within the timed execution. Note that this differs from the default JUnit behavior of executing @Before and @After methods in the main thread while executing the actual test method in a separate thread. Thus, the net effect is that @Before and @After methods will be executed in the same thread as the test method. As a consequence, JUnit-specified timeouts will work fine in combination with Spring transactions. However, JUnit-specific timeouts still differ from Spring-specific timeouts in that the former execute in a separate thread while the latter simply execute in the main thread (like regular tests).

Overrides:

methodBlock in class BlockJUnit4ClassRunner

See Also:

possiblyExpectingExceptions(FrameworkMethod, Object, Statement), withBefores(FrameworkMethod, Object, Statement), withAfters(FrameworkMethod, Object, Statement), withRulesReflectively(FrameworkMethod, Object, Statement), withPotentialRepeat(FrameworkMethod, Object, Statement), withPotentialTimeout(FrameworkMethod, Object, Statement)

isTestMethodIgnored

protected boolean isTestMethodIgnored(FrameworkMethod frameworkMethod)

Return true if @Ignore is present for the supplied test method or if the test method is disabled via @IfProfileValue.

See Also:

ProfileValueUtils.isTestEnabledInThisEnvironment(Method, Class)

possiblyExpectingExceptions

protected Statement possiblyExpectingExceptions(FrameworkMethod frameworkMethod,
                                                java.lang.Object testInstance,
                                                Statement next)

Perform the same logic as BlockJUnit4ClassRunner.possiblyExpectingExceptions(FrameworkMethod, Object, Statement) except that the expected exception is retrieved using getExpectedException(FrameworkMethod).

Overrides:

possiblyExpectingExceptions in class BlockJUnit4ClassRunner

getExpectedException

protected java.lang.Class<? extends java.lang.Throwable> getExpectedException(FrameworkMethod frameworkMethod)

Get the exception that the supplied test method is expected to throw.

Supports JUnit's @Test(expected=...) annotation.

Can be overridden by subclasses.

Returns:

the expected exception, or null if none was specified

withPotentialTimeout

protected Statement withPotentialTimeout(FrameworkMethod frameworkMethod,
                                         java.lang.Object testInstance,
                                         Statement next)

Perform the same logic as BlockJUnit4ClassRunner.withPotentialTimeout(FrameworkMethod, Object, Statement) but with additional support for Spring's @Timed annotation.

Supports both Spring's @Timed and JUnit's @Test(timeout=...) annotations, but not both simultaneously.

Overrides:

withPotentialTimeout in class BlockJUnit4ClassRunner

Returns:

either a SpringFailOnTimeout, a FailOnTimeout, or the supplied Statement as appropriate

See Also:

getSpringTimeout(FrameworkMethod), getJUnitTimeout(FrameworkMethod)

getJUnitTimeout

protected long getJUnitTimeout(FrameworkMethod frameworkMethod)

Retrieve the configured JUnit timeout from the @Test annotation on the supplied test method.

Returns:

the timeout, or 0 if none was specified

getSpringTimeout

protected long getSpringTimeout(FrameworkMethod frameworkMethod)

Retrieve the configured Spring-specific timeout from the @Timed annotation on the supplied test method.

Returns:

the timeout, or 0 if none was specified

See Also:

TestAnnotationUtils.getTimeout(Method)

withBefores

protected Statement withBefores(FrameworkMethod frameworkMethod,
                                java.lang.Object testInstance,
                                Statement statement)

Wrap the Statement returned by the parent implementation with a RunBeforeTestMethodCallbacks statement, thus preserving the default functionality while adding support for the Spring TestContext Framework.

Overrides:

withBefores in class BlockJUnit4ClassRunner

See Also:

RunBeforeTestMethodCallbacks

withAfters

protected Statement withAfters(FrameworkMethod frameworkMethod,
                               java.lang.Object testInstance,
                               Statement statement)

Wrap the Statement returned by the parent implementation with a RunAfterTestMethodCallbacks statement, thus preserving the default functionality while adding support for the Spring TestContext Framework.

Overrides:

withAfters in class BlockJUnit4ClassRunner

See Also:

RunAfterTestMethodCallbacks

withPotentialRepeat

protected Statement withPotentialRepeat(FrameworkMethod frameworkMethod,
                                        java.lang.Object testInstance,
                                        Statement next)

Wrap the supplied Statement with a SpringRepeat statement.

Supports Spring's @Repeat annotation.

See Also:

TestAnnotationUtils.getRepeatCount(Method), SpringRepeat