|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.ObjectBlockJUnit4ClassRunner
org.springframework.test.context.junit4.SpringJUnit4ClassRunner
public class SpringJUnit4ClassRunner
SpringJUnit4ClassRunner
is a custom extension of
BlockJUnit4ClassRunner
which provides functionality of the
Spring TestContext Framework to standard JUnit 4.5+ tests by means
of the TestContextManager
and associated support classes and
annotations.
The following list constitutes all annotations currently supported directly
by SpringJUnit4ClassRunner
.
(Note that additional annotations may be supported by various
TestExecutionListeners
)
@Test(expected=...)
@ExpectedException
@Test(timeout=...)
@Timed
@Repeat
@Ignore
@ProfileValueSourceConfiguration
@IfProfileValue
NOTE: As of Spring 3.0, SpringJUnit4ClassRunner
requires
JUnit 4.5+.
TestContextManager
Field Summary | |
---|---|
private static Log |
logger
|
private TestContextManager |
testContextManager
|
Constructor Summary | |
---|---|
SpringJUnit4ClassRunner(java.lang.Class<?> clazz)
Constructs a new SpringJUnit4ClassRunner and initializes a
TestContextManager to provide Spring testing functionality to
standard JUnit tests. |
Method Summary | |
---|---|
protected java.lang.Object |
createTest()
Delegates to the parent implementation for creating the test instance and then allows the TestContextManager to
prepare the test instance before returning it. |
protected TestContextManager |
createTestContextManager(java.lang.Class<?> clazz)
Creates a new TestContextManager for the supplied test class and
the configured default ContextLoader class name. |
protected java.lang.String |
getDefaultContextLoaderClassName(java.lang.Class<?> clazz)
Get the name of the default ContextLoader class to use for
the supplied test class. |
Description |
getDescription()
Returns a description suitable for an ignored test class if the test is disabled via @IfProfileValue at the class-level, and
otherwise delegates 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)
Retrieves the configured JUnit timeout from the @Test annotation on the supplied test method . |
protected long |
getSpringTimeout(FrameworkMethod frameworkMethod)
Retrieves 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)
Returns true if @Ignore is present for
the supplied test method or if the test method is
disabled via @IfProfileValue . |
protected Statement |
methodBlock(FrameworkMethod frameworkMethod)
Augments the default JUnit behavior with
potential repeats of the entire execution chain. |
protected Statement |
possiblyExpectingExceptions(FrameworkMethod frameworkMethod,
java.lang.Object testInstance,
Statement next)
Performs 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 first place. |
protected void |
runChild(FrameworkMethod frameworkMethod,
RunNotifier notifier)
Performs the same logic as BlockJUnit4ClassRunner#runChild(FrameworkMethod, RunNotifier) ,
except that tests are determined to be ignored by
isTestMethodIgnored(FrameworkMethod) . |
private EachTestNotifier |
springMakeNotifier(FrameworkMethod method,
RunNotifier notifier)
springMakeNotifier() is an exact copy of
BlockJUnit4ClassRunner's
makeNotifier() method, but we have decided to prefix it with
"spring" and keep it private in order to avoid the
compatibility clashes that were introduced in JUnit between versions 4.5,
4.6, and 4.7. |
protected Statement |
withAfterClasses(Statement statement)
Wraps the Statement returned by the parent implementation with a
RunAfterTestClassCallbacks statement, thus preserving the default
functionality but adding support for the Spring TestContext Framework. |
protected Statement |
withAfters(FrameworkMethod frameworkMethod,
java.lang.Object testInstance,
Statement statement)
Wraps the Statement returned by the parent implementation with a
RunAfterTestMethodCallbacks statement, thus preserving the
default functionality but adding support for the Spring TestContext
Framework. |
protected Statement |
withBeforeClasses(Statement statement)
Wraps the Statement returned by the parent implementation with a
RunBeforeTestClassCallbacks statement, thus preserving the
default functionality but adding support for the Spring TestContext
Framework. |
protected Statement |
withBefores(FrameworkMethod frameworkMethod,
java.lang.Object testInstance,
Statement statement)
Wraps the Statement returned by the parent implementation with a
RunBeforeTestMethodCallbacks statement, thus preserving the
default functionality but adding support for the Spring TestContext
Framework. |
protected Statement |
withPotentialRepeat(FrameworkMethod frameworkMethod,
java.lang.Object testInstance,
Statement next)
Supports Spring's @Repeat annotation by returning a
SpringRepeat statement initialized with the configured repeat
count or 1 if no repeat count is configured. |
protected Statement |
withPotentialTimeout(FrameworkMethod frameworkMethod,
java.lang.Object testInstance,
Statement next)
Supports both Spring's @Timed and JUnit's
@Test(timeout=...) annotations, but not both
simultaneously. |
private Statement |
withRulesReflectively(FrameworkMethod frameworkMethod,
java.lang.Object testInstance,
Statement statement)
Invokes JUnit 4.7's private withRules() method using
reflection. |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
---|
private static final Log logger
private final TestContextManager testContextManager
Constructor Detail |
---|
public SpringJUnit4ClassRunner(java.lang.Class<?> clazz) throws InitializationError
SpringJUnit4ClassRunner
and initializes a
TestContextManager
to provide Spring testing functionality to
standard JUnit tests.
clazz
- the test class to be run
InitializationError
createTestContextManager(Class)
Method Detail |
---|
protected TestContextManager createTestContextManager(java.lang.Class<?> clazz)
TestContextManager
for the supplied test class and
the configured default ContextLoader
class name.
Can be overridden by subclasses.
clazz
- the test class to be managedgetDefaultContextLoaderClassName(Class)
protected final TestContextManager getTestContextManager()
TestContextManager
associated with this runner.
protected java.lang.String getDefaultContextLoaderClassName(java.lang.Class<?> clazz)
ContextLoader
class to use for
the supplied test class. The named class will be used if the test class
does not explicitly declare a ContextLoader
class via the
@ContextConfiguration
annotation.
The default implementation returns null
, thus implying use
of the standard default ContextLoader
class name.
Can be overridden by subclasses.
clazz
- the test class
null
public Description getDescription()
@IfProfileValue
at the class-level, and
otherwise delegates to the parent implementation.
ProfileValueUtils.isTestEnabledInThisEnvironment(Class)
public void run(RunNotifier notifier)
@IfProfileValue
annotation
from running altogether, even skipping the execution of
prepareTestInstance()
TestExecutionListener
methods.
ProfileValueUtils.isTestEnabledInThisEnvironment(Class)
,
IfProfileValue
,
TestExecutionListener
protected Statement withBeforeClasses(Statement statement)
Statement
returned by the parent implementation with a
RunBeforeTestClassCallbacks
statement, thus preserving the
default functionality but 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
functionality but 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(Object)
protected void runChild(FrameworkMethod frameworkMethod, RunNotifier notifier)
BlockJUnit4ClassRunner#runChild(FrameworkMethod, RunNotifier)
,
except that tests are determined to be ignored by
isTestMethodIgnored(FrameworkMethod)
.
private EachTestNotifier springMakeNotifier(FrameworkMethod method, RunNotifier notifier)
springMakeNotifier()
is an exact copy of
BlockJUnit4ClassRunner's
makeNotifier()
method, but we have decided to prefix it with
"spring" and keep it private
in order to avoid the
compatibility clashes that were introduced in JUnit between versions 4.5,
4.6, and 4.7.
protected Statement methodBlock(FrameworkMethod frameworkMethod)
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 end 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. Note that 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)
,
withPotentialTimeout(FrameworkMethod, Object, Statement)
,
withPotentialRepeat(FrameworkMethod, Object, Statement)
private Statement withRulesReflectively(FrameworkMethod frameworkMethod, java.lang.Object testInstance, Statement statement)
withRules()
method using
reflection. This is necessary for backwards compatibility with the JUnit
4.5 and 4.6 implementations of BlockJUnit4ClassRunner
.
protected boolean isTestMethodIgnored(FrameworkMethod frameworkMethod)
true
if @Ignore
is present for
the supplied test method
or if the test method is
disabled via @IfProfileValue
.
ProfileValueUtils.isTestEnabledInThisEnvironment(Method, Class)
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 both Spring's @ExpectedException(...)
and JUnit's @Test(expected=...)
annotations, but
not both simultaneously.
null
if none was specifiedprotected Statement withPotentialTimeout(FrameworkMethod frameworkMethod, java.lang.Object testInstance, Statement next)
@Timed
and JUnit's
@Test(timeout=...)
annotations, but not both
simultaneously. Returns either a SpringFailOnTimeout
, a
FailOnTimeout
, or the unmodified, supplied Statement
as
appropriate.
getSpringTimeout(FrameworkMethod)
,
getJUnitTimeout(FrameworkMethod)
protected long getJUnitTimeout(FrameworkMethod frameworkMethod)
timeout
from the @Test
annotation on the supplied test method
.
0
if none was specified.protected long getSpringTimeout(FrameworkMethod frameworkMethod)
timeout
from the
@Timed
annotation on the supplied
test method
.
0
if none was specified.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 but 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 but adding support for the Spring TestContext
Framework.
RunAfterTestMethodCallbacks
protected Statement withPotentialRepeat(FrameworkMethod frameworkMethod, java.lang.Object testInstance, Statement next)
@Repeat
annotation by returning a
SpringRepeat
statement initialized with the configured repeat
count or 1
if no repeat count is configured.
SpringRepeat
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |