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.
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.1, this class requires JUnit 4.9 or higher.
TestContextManager
,
AbstractJUnit4SpringContextTests
,
AbstractTransactionalJUnit4SpringContextTests
,
SpringClassRule
,
SpringMethodRule
Modifier and Type | Field and Description |
---|---|
private static Log |
logger |
private TestContextManager |
testContextManager |
private static java.lang.reflect.Method |
withRulesMethod |
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. |
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. |
private static void |
ensureSpringRulesAreNotPresent(java.lang.Class<?> testClass) |
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. |
private Statement |
withRulesReflectively(FrameworkMethod frameworkMethod,
java.lang.Object testInstance,
Statement statement)
Invoke JUnit's private
withRules() method using reflection. |
private static final Log logger
private static final java.lang.reflect.Method withRulesMethod
private final TestContextManager testContextManager
public SpringJUnit4ClassRunner(java.lang.Class<?> clazz) throws InitializationError
SpringJUnit4ClassRunner
and initialize a
TestContextManager
to provide Spring testing functionality to
standard JUnit tests.clazz
- the test class to be runInitializationError
createTestContextManager(Class)
private static void ensureSpringRulesAreNotPresent(java.lang.Class<?> testClass)
protected TestContextManager createTestContextManager(java.lang.Class<?> clazz)
TestContextManager
for the supplied test class.
Can be overridden by subclasses.
clazz
- the test class to be managedprotected final TestContextManager getTestContextManager()
TestContextManager
associated with this runner.public Description getDescription()
@IfProfileValue
at the class-level, and
otherwise delegate to the parent implementation.public void run(RunNotifier notifier)
This prevents classes with a non-matching @IfProfileValue
annotation from running altogether, even skipping the execution of
prepareTestInstance()
methods in TestExecutionListeners
.
protected Statement withBeforeClasses(Statement statement)
Statement
returned by the parent implementation with a
RunBeforeTestClassCallbacks
statement, thus preserving the
default JUnit functionality while adding support for the Spring TestContext
Framework.RunBeforeTestClassCallbacks
protected Statement withAfterClasses(Statement statement)
Statement
returned by the parent implementation with a
RunAfterTestClassCallbacks
statement, thus preserving the default
JUnit functionality while adding support for the Spring TestContext Framework.RunAfterTestClassCallbacks
protected java.lang.Object createTest() throws java.lang.Exception
TestContextManager
to
prepare the test instance before returning it.java.lang.Exception
TestContextManager.prepareTestInstance(java.lang.Object)
protected void runChild(FrameworkMethod frameworkMethod, RunNotifier notifier)
BlockJUnit4ClassRunner#runChild(FrameworkMethod, RunNotifier)
,
except that tests are determined to be ignored by
isTestMethodIgnored(FrameworkMethod)
.protected Statement methodBlock(FrameworkMethod frameworkMethod)
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).
possiblyExpectingExceptions(FrameworkMethod, Object, Statement)
,
withBefores(FrameworkMethod, Object, Statement)
,
withAfters(FrameworkMethod, Object, Statement)
,
withRulesReflectively(FrameworkMethod, Object, Statement)
,
withPotentialRepeat(FrameworkMethod, Object, Statement)
,
withPotentialTimeout(FrameworkMethod, Object, Statement)
private Statement withRulesReflectively(FrameworkMethod frameworkMethod, java.lang.Object testInstance, Statement statement)
withRules()
method using reflection.protected boolean isTestMethodIgnored(FrameworkMethod frameworkMethod)
true
if @Ignore
is present for the supplied
test method or if the test method is disabled
via @IfProfileValue
.protected Statement possiblyExpectingExceptions(FrameworkMethod frameworkMethod, java.lang.Object testInstance, Statement next)
BlockJUnit4ClassRunner#possiblyExpectingExceptions(FrameworkMethod, Object, Statement)
except that the expected exception is retrieved using
getExpectedException(FrameworkMethod)
.protected java.lang.Class<? extends java.lang.Throwable> getExpectedException(FrameworkMethod frameworkMethod)
exception
that the supplied test method is expected to throw.
Supports JUnit's @Test(expected=...)
annotation.
Can be overridden by subclasses.
null
if none was specifiedprotected Statement withPotentialTimeout(FrameworkMethod frameworkMethod, java.lang.Object testInstance, Statement next)
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.
SpringFailOnTimeout
, a FailOnTimeout
,
or the supplied Statement
as appropriategetSpringTimeout(FrameworkMethod)
,
getJUnitTimeout(FrameworkMethod)
protected long getJUnitTimeout(FrameworkMethod frameworkMethod)
timeout
from the @Test
annotation on the supplied test method.0
if none was specifiedprotected long getSpringTimeout(FrameworkMethod frameworkMethod)
timeout
from the
@Timed
annotation
on the supplied test method.0
if none was specifiedTestAnnotationUtils.getTimeout(Method)
protected Statement withBefores(FrameworkMethod frameworkMethod, java.lang.Object testInstance, Statement statement)
Statement
returned by the parent implementation with a
RunBeforeTestMethodCallbacks
statement, thus preserving the
default functionality while adding support for the Spring TestContext
Framework.RunBeforeTestMethodCallbacks
protected Statement withAfters(FrameworkMethod frameworkMethod, java.lang.Object testInstance, Statement statement)
Statement
returned by the parent implementation with a
RunAfterTestMethodCallbacks
statement, thus preserving the
default functionality while adding support for the Spring TestContext
Framework.RunAfterTestMethodCallbacks
protected Statement withPotentialRepeat(FrameworkMethod frameworkMethod, java.lang.Object testInstance, Statement next)