AbstractSingleSpringContextTests (Spring Framework 3.2.1.RELEASE API)
Date: 2013-01-24

org.springframework.test

## Class AbstractSingleSpringContextTests

- java.lang.Object
- - junit.framework.Assert
  - - junit.framework.TestCase
    - - org.springframework.test.ConditionalTestCase
      - - org.springframework.test.AbstractSpringContextTests
        - - org.springframework.test.AbstractSingleSpringContextTests

- All Implemented Interfaces:
    junit.framework.Test
  Direct Known Subclasses:
    AbstractDependencyInjectionSpringContextTests

  Deprecated.
  as of Spring 3.0, in favor of using the listener-based test context framework (`AbstractJUnit4SpringContextTests`)

      @Deprecated
      public abstract class AbstractSingleSpringContextTests
      extends AbstractSpringContextTests

  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.

  Since:
    2.0
  Author:
    Juergen Hoeller, Rod Johnson, Sam Brannen
  See Also:
    `getConfigLocations()`, `contextKey()`, `loadContext(Object)`, `getApplicationContext()`

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected ConfigurableApplicationContext` | `applicationContext` Deprecated. Application context this test will run against

    - ### Fields inherited from class org.springframework.test.ConditionalTestCase

      `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AbstractSingleSpringContextTests()` Deprecated. Default constructor for AbstractSingleSpringContextTests.
    `AbstractSingleSpringContextTests(String name)` Deprecated. Constructor for AbstractSingleSpringContextTests with a JUnit name.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected Object` | `contextKey()` Deprecated. Return a key for this context.
    `protected ConfigurableApplicationContext` | `createApplicationContext(String[] locations)` Deprecated. Create a Spring `ConfigurableApplicationContext` for use by this test.
    `protected BeanDefinitionReader` | `createBeanDefinitionReader(GenericApplicationContext context)` Deprecated. Factory method for creating new `BeanDefinitionReader`s for loading bean definitions into the supplied `context`.
    `protected void` | `customizeBeanFactory(DefaultListableBeanFactory beanFactory)` Deprecated. Customize the internal bean factory of the ApplicationContext used by this test.
    `ConfigurableApplicationContext` | `getApplicationContext()` Deprecated. Return the ApplicationContext that this base class manages; may be `null`.
    `protected String[]` | `getConfigLocations()` Deprecated. Subclasses can override this method to return the locations of their config files, unless they override `contextKey()` and `loadContext(Object)` instead.
    `protected String` | `getConfigPath()` Deprecated. Subclasses can override this method to return a single path to a config file, relative to the concrete test class.
    `protected String[]` | `getConfigPaths()` Deprecated. Subclasses can override this method to return paths to their config files, relative to the concrete test class.
    `int` | `getLoadCount()` Deprecated. Return the current number of context load attempts.
    `protected ConfigurableApplicationContext` | `loadContext(Object key)` Deprecated. This implementation assumes a key of type String array and loads a context from the given locations.
    `protected ConfigurableApplicationContext` | `loadContextLocations(String[] locations)` Deprecated. Load a Spring ApplicationContext from the given config locations.
    `protected void` | `onSetUp()` Deprecated. Subclasses can override this method in place of the `setUp()` method, which is final in this class.
    `protected void` | `onTearDown()` Deprecated. Subclasses can override this to add custom behavior on teardown.
    `protected void` | `prepareApplicationContext(GenericApplicationContext context)` Deprecated. Prepare the GenericApplicationContext used by this test.
    `protected void` | `prepareTestInstance()` Deprecated. Prepare this test instance, for example populating its fields.
    `protected void` | `setDirty()` Deprecated. Called to say that the "applicationContext" instance variable is dirty and should be reloaded.
    `protected void` | `setUp()` Deprecated. This implementation is final.
    `protected void` | `tearDown()` Deprecated. 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

    - #### applicationContext

          protected ConfigurableApplicationContext applicationContext

      Deprecated.
      Application context this test will run against

  - ### Constructor Detail

    - #### AbstractSingleSpringContextTests

          public AbstractSingleSpringContextTests()

      Deprecated.
      Default constructor for AbstractSingleSpringContextTests.

    - #### AbstractSingleSpringContextTests

          public AbstractSingleSpringContextTests(String name)

      Deprecated.
      Constructor for AbstractSingleSpringContextTests with a JUnit name.
      Parameters:
        `name` - the name of this text fixture

  - ### Method Detail

    - #### setUp

          protected final void setUp()
                              throws Exception

      Deprecated.
      This implementation is final. Override `onSetUp` for custom behavior.
      Overrides:
        `setUp` in class `junit.framework.TestCase`
      Throws:
        `Exception`
      See Also:
        `onSetUp()`

    - #### prepareTestInstance

          protected void prepareTestInstance()
                                      throws Exception

      Deprecated.
      Prepare this test instance, for example populating its fields. The context has already been loaded at the time of this callback.

      The default implementation does nothing.

      Throws:
        `Exception` - in case of preparation failure

    - #### onSetUp

          protected void onSetUp()
                          throws Exception

      Deprecated.
      Subclasses can override this method in place of the `setUp()` method, which is final in this class.

      The default implementation does nothing.

      Throws:
        `Exception` - simply let any exception propagate

    - #### setDirty

          protected void setDirty()

      Deprecated.
      Called to say that the "applicationContext" instance variable is dirty and should be reloaded. We need to do this if a test has modified the context (for example, by replacing a bean definition).

    - #### tearDown

          protected final void tearDown()
                                 throws Exception

      Deprecated.
      This implementation is final. Override `onTearDown` for custom behavior.
      Overrides:
        `tearDown` in class `junit.framework.TestCase`
      Throws:
        `Exception`
      See Also:
        `onTearDown()`

    - #### onTearDown

          protected void onTearDown()
                             throws Exception

      Deprecated.
      Subclasses can override this to add custom behavior on teardown.
      Throws:
        `Exception` - simply let any exception propagate

    - #### contextKey

          protected Object contextKey()

      Deprecated.
      Return a key for this context. Default is the config location array as determined by `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.

      Returns:
        the context key
      See Also:
        `getConfigLocations()`

    - #### loadContext

          protected ConfigurableApplicationContext loadContext(Object key)
                                                        throws Exception

      Deprecated.
      This implementation assumes a key of type String array and loads a context from the given locations.

      If you override `contextKey()`, you will typically have to override this method as well, being able to handle the key type that `contextKey()` returns.

      Specified by:
        `loadContext` in class `AbstractSpringContextTests`
      Parameters:
        `key` - the context key
      Returns:
        the corresponding ApplicationContext instance (new)
      Throws:
        `Exception`
      See Also:
        `getConfigLocations()`

    - #### loadContextLocations

          protected ConfigurableApplicationContext loadContextLocations(String[] locations)
                                                                 throws Exception

      Deprecated.
      Load a Spring ApplicationContext from the given config locations.

      The default implementation creates a standard `GenericApplicationContext`, allowing for customizing the internal bean factory through `customizeBeanFactory(org.springframework.beans.factory.support.DefaultListableBeanFactory)`.

      Parameters:
        `locations` - the config locations (as Spring resource locations, e.g. full classpath locations or any kind of URL)
      Returns:
        the corresponding ApplicationContext instance (potentially cached)
      Throws:
        `Exception` - if context loading failed
      See Also:
        `createApplicationContext(String[])`

    - #### createApplicationContext

          protected ConfigurableApplicationContext createApplicationContext(String[] locations)

      Deprecated.
      Create a Spring `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.

      Parameters:
        `locations` - the config locations (as Spring resource locations, e.g. full classpath locations or any kind of URL)
      Returns:
        the GenericApplicationContext instance
      See Also:
        `loadContextLocations(String[])`, `customizeBeanFactory(DefaultListableBeanFactory)`, `createBeanDefinitionReader(GenericApplicationContext)`

    - #### prepareApplicationContext

          protected void prepareApplicationContext(GenericApplicationContext context)

      Deprecated.
      Prepare the GenericApplicationContext used by this test. Called before bean definitions are read.

      The default implementation is empty. Can be overridden in subclasses to customize GenericApplicationContext's standard settings.

      Parameters:
        `context` - the context for which the BeanDefinitionReader should be created
      See Also:
        `createApplicationContext(java.lang.String[])`, `GenericApplicationContext.setResourceLoader(org.springframework.core.io.ResourceLoader)`, `GenericApplicationContext.setId(java.lang.String)`

    - #### customizeBeanFactory

          protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory)

      Deprecated.
      Customize the internal bean factory of the ApplicationContext used by this test. Called before bean definitions are read.

      The default implementation is empty. Can be overridden in subclasses to customize DefaultListableBeanFactory's standard settings.

      Parameters:
        `beanFactory` - the newly created bean factory for this context
      See Also:
        `loadContextLocations(java.lang.String[])`, `createApplicationContext(java.lang.String[])`, `DefaultListableBeanFactory.setAllowBeanDefinitionOverriding(boolean)`, `DefaultListableBeanFactory.setAllowEagerClassLoading(boolean)`, `AbstractAutowireCapableBeanFactory.setAllowCircularReferences(boolean)`, `AbstractAutowireCapableBeanFactory.setAllowRawInjectionDespiteWrapping(boolean)`

    - #### createBeanDefinitionReader

          protected BeanDefinitionReader createBeanDefinitionReader(GenericApplicationContext context)

      Deprecated.
      Factory method for creating new `BeanDefinitionReader`s 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.

      Parameters:
        `context` - the context for which the BeanDefinitionReader should be created
      Returns:
        a BeanDefinitionReader for the supplied context
      See Also:
        `createApplicationContext(String[])`, `BeanDefinitionReader`, `XmlBeanDefinitionReader`

    - #### getConfigLocations

          protected String[] getConfigLocations()

      Deprecated.
      Subclasses can override this method to return the locations of their config files, unless they override `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()`.

      Returns:
        an array of config locations
      See Also:
        `getConfigPaths()`, `ResourceLoader.getResource(String)`

    - #### getConfigPaths

          protected String[] getConfigPaths()

      Deprecated.
      Subclasses can override this method to return paths to their config files, relative to the concrete test class.

      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()`.

      Returns:
        an array of config locations
      See Also:
        `getConfigPath()`, `Class.getResource(String)`

    - #### getConfigPath

          protected String getConfigPath()

      Deprecated.
      Subclasses can override this method to return a single path to a config file, relative to the concrete test class.

      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`.

      Returns:
        an array of config locations
      See Also:
        `getConfigPath()`, `Class.getResource(String)`

    - #### getApplicationContext

          public final ConfigurableApplicationContext getApplicationContext()

      Deprecated.
      Return the ApplicationContext that this base class manages; may be `null`.

    - #### getLoadCount

          public final int getLoadCount()

      Deprecated.
      Return the current number of context load attempts.