| 
 | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectjunit.framework.Assert
junit.framework.TestCase
org.springframework.test.ConditionalTestCase
org.springframework.test.AbstractSpringContextTests
org.springframework.test.AbstractSingleSpringContextTests
public abstract class AbstractSingleSpringContextTests
 Abstract JUnit 3.8 test class that holds and exposes a single Spring
 ApplicationContext.
 
 This class will cache contexts based on a context key: normally the
 config locations String array describing the Spring resource descriptors
 making up the context. Unless the setDirty() method is called by a
 test, the context will not be reloaded, even across different subclasses of
 this test. This is particularly beneficial if your context is slow to
 construct, for example if you are using Hibernate and the time taken to load
 the mappings is an issue.
 
 For such standard usage, simply override the getConfigLocations()
 method and provide the desired config files. For alternative configuration
 options, see getConfigPath() and getConfigPaths().
 
 If you don't want to load a standard context from an array of config
 locations, you can override the contextKey() method. In conjunction
 with this you typically need to override the loadContext(Object)
 method, which by default loads the locations specified in the
 getConfigLocations() method.
 
WARNING: When doing integration tests from within Eclipse, only use classpath resource URLs. Else, you may see misleading failures when changing context locations.
getConfigLocations(), 
contextKey(), 
loadContext(Object), 
getApplicationContext()| Field Summary | |
|---|---|
| protected  ConfigurableApplicationContext | applicationContextApplication context this test will run against | 
| Fields inherited from class org.springframework.test.ConditionalTestCase | 
|---|
| logger | 
| Constructor Summary | |
|---|---|
| AbstractSingleSpringContextTests()Default constructor for AbstractSingleSpringContextTests. | |
| AbstractSingleSpringContextTests(String name)Constructor for AbstractSingleSpringContextTests with a JUnit name. | |
| Method Summary | |
|---|---|
| protected  Object | contextKey()Return a key for this context. | 
| protected  ConfigurableApplicationContext | createApplicationContext(String[] locations)Create a Spring ConfigurableApplicationContextfor use by this test. | 
| protected  BeanDefinitionReader | createBeanDefinitionReader(GenericApplicationContext context)Factory method for creating new BeanDefinitionReaders for
 loading bean definitions into the suppliedcontext. | 
| protected  void | customizeBeanFactory(DefaultListableBeanFactory beanFactory)Customize the internal bean factory of the ApplicationContext used by this test. | 
|  ConfigurableApplicationContext | getApplicationContext()Return the ApplicationContext that this base class manages; may be null. | 
| protected  String[] | getConfigLocations()Subclasses can override this method to return the locations of their config files, unless they override contextKey()andloadContext(Object)instead. | 
| protected  String | getConfigPath()Subclasses can override this method to return a single path to a config file, relative to the concrete test class. | 
| protected  String[] | getConfigPaths()Subclasses can override this method to return paths to their config files, relative to the concrete test class. | 
|  int | getLoadCount()Return the current number of context load attempts. | 
| protected  ConfigurableApplicationContext | loadContext(Object key)This implementation assumes a key of type String array and loads a context from the given locations. | 
| protected  ConfigurableApplicationContext | loadContextLocations(String[] locations)Load a Spring ApplicationContext from the given config locations. | 
| protected  void | onSetUp()Subclasses can override this method in place of the setUp()method, which is final in this class. | 
| protected  void | onTearDown()Subclasses can override this to add custom behavior on teardown. | 
| protected  void | prepareApplicationContext(GenericApplicationContext context)Prepare the GenericApplicationContext used by this test. | 
| protected  void | prepareTestInstance()Prepare this test instance, for example populating its fields. | 
| protected  void | setDirty()Called to say that the "applicationContext" instance variable is dirty and should be reloaded. | 
| protected  void | setUp()This implementation is final. | 
| protected  void | tearDown()This implementation is final. | 
| Methods inherited from class org.springframework.test.AbstractSpringContextTests | 
|---|
| addContext, contextKeyString, getContext, hasCachedContext, isContextKeyEmpty, setDirty | 
| Methods inherited from class org.springframework.test.ConditionalTestCase | 
|---|
| getDisabledTestCount, isDisabledInThisEnvironment, recordDisabled, runBare | 
| Methods inherited from class junit.framework.TestCase | 
|---|
| countTestCases, createResult, getName, run, run, runTest, setName, toString | 
| Methods inherited from class junit.framework.Assert | 
|---|
| assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertFalse, assertFalse, assertNotNull, assertNotNull, assertNotSame, assertNotSame, assertNull, assertNull, assertSame, assertSame, assertTrue, assertTrue, fail, fail, failNotEquals, failNotSame, failSame, format | 
| Methods inherited from class java.lang.Object | 
|---|
| clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait | 
| Field Detail | 
|---|
protected ConfigurableApplicationContext applicationContext
| Constructor Detail | 
|---|
public AbstractSingleSpringContextTests()
public AbstractSingleSpringContextTests(String name)
name - the name of this text fixture| Method Detail | 
|---|
protected final void setUp()
                    throws Exception
onSetUp for custom behavior.
setUp in class junit.framework.TestCaseExceptiononSetUp()
protected void prepareTestInstance()
                            throws Exception
The default implementation does nothing.
Exception - in case of preparation failure
protected void onSetUp()
                throws Exception
setUp()
 method, which is final in this class.
 The default implementation does nothing.
Exception - simply let any exception propagateprotected void setDirty()
protected final void tearDown()
                       throws Exception
onTearDown for
 custom behavior.
tearDown in class junit.framework.TestCaseExceptiononTearDown()
protected void onTearDown()
                   throws Exception
Exception - simply let any exception propagateprotected Object contextKey()
getConfigLocations().
 If you override this method, you will typically have to override
 loadContext(Object) as well, being able to handle the key type
 that this method returns.
getConfigLocations()
protected ConfigurableApplicationContext loadContext(Object key)
                                              throws Exception
If you override contextKey(), you will typically have to
 override this method as well, being able to handle the key type that
 contextKey() returns.
loadContext in class AbstractSpringContextTestskey - the context key
ExceptiongetConfigLocations()
protected ConfigurableApplicationContext loadContextLocations(String[] locations)
                                                       throws Exception
The default implementation creates a standard
 GenericApplicationContext, allowing
 for customizing the internal bean factory through
 customizeBeanFactory(org.springframework.beans.factory.support.DefaultListableBeanFactory).
locations - the config locations (as Spring resource locations,
 e.g. full classpath locations or any kind of URL)
Exception - if context loading failedcreateApplicationContext(String[])protected ConfigurableApplicationContext createApplicationContext(String[] locations)
ConfigurableApplicationContext for use by this test.
 The default implementation creates a standard GenericApplicationContext
 instance, calls the prepareApplicationContext(org.springframework.context.support.GenericApplicationContext) prepareApplicationContext}
 method and the customizeBeanFactory method to allow
 for customizing the context and its DefaultListableBeanFactory, populates the
 context from the specified config locations through the configured
 BeanDefinitionReader,
 and finally refreshes the context.
locations - the config locations (as Spring resource locations,
 e.g. full classpath locations or any kind of URL)
loadContextLocations(String[]), 
customizeBeanFactory(DefaultListableBeanFactory), 
createBeanDefinitionReader(GenericApplicationContext)protected void prepareApplicationContext(GenericApplicationContext context)
The default implementation is empty. Can be overridden in subclasses to customize GenericApplicationContext's standard settings.
context - the context for which the BeanDefinitionReader should be createdcreateApplicationContext(java.lang.String[]), 
GenericApplicationContext.setResourceLoader(org.springframework.core.io.ResourceLoader), 
AbstractApplicationContext.setId(java.lang.String)protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory)
The default implementation is empty. Can be overridden in subclasses to customize DefaultListableBeanFactory's standard settings.
beanFactory - the newly created bean factory for this contextloadContextLocations(java.lang.String[]), 
createApplicationContext(java.lang.String[]), 
DefaultListableBeanFactory.setAllowBeanDefinitionOverriding(boolean), 
DefaultListableBeanFactory.setAllowEagerClassLoading(boolean), 
AbstractAutowireCapableBeanFactory.setAllowCircularReferences(boolean), 
AbstractAutowireCapableBeanFactory.setAllowRawInjectionDespiteWrapping(boolean)protected BeanDefinitionReader createBeanDefinitionReader(GenericApplicationContext context)
BeanDefinitionReaders for
 loading bean definitions into the supplied
 context.
 The default implementation creates a new XmlBeanDefinitionReader.
 Can be overridden in subclasses to provide a different
 BeanDefinitionReader implementation.
context - the context for which the BeanDefinitionReader should be created
createApplicationContext(String[]), 
BeanDefinitionReader, 
XmlBeanDefinitionReaderprotected String[] getConfigLocations()
contextKey() and
 loadContext(Object) instead.
 A plain path will be treated as class path location, e.g.: "org/springframework/whatever/foo.xml". Note however that you may prefix path locations with standard Spring resource prefixes. Therefore, a config location path prefixed with "classpath:" with behave the same as a plain path, but a config location such as "file:/some/path/path/location/appContext.xml" will be treated as a filesystem location.
The default implementation builds config locations for the config paths
 specified through getConfigPaths().
getConfigPaths(), 
ResourceLoader.getResource(String)protected String[] getConfigPaths()
A plain path, e.g. "context.xml", will be loaded as classpath resource from the same package that the concrete test class is defined in. A path starting with a slash is treated as fully qualified class path location, e.g.: "/org/springframework/whatever/foo.xml".
The default implementation builds an array for the config path specified
 through getConfigPath().
getConfigPath(), 
Class.getResource(String)protected String getConfigPath()
A plain path, e.g. "context.xml", will be loaded as classpath resource from the same package that the concrete test class is defined in. A path starting with a slash is treated as fully qualified class path location, e.g.: "/org/springframework/whatever/foo.xml".
The default implementation simply returns null.
getConfigPath(), 
Class.getResource(String)public final ConfigurableApplicationContext getApplicationContext()
null.
public final int getLoadCount()
| 
 | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||