Java tutorial
/* * Copyright 2002-2007 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.testng.spring.test; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.util.StringUtils; import org.testng.annotations.BeforeMethod; import org.testng.annotations.AfterMethod; /** * Abstract JUnit test class that holds and exposes a single Spring * {@link org.springframework.context.ApplicationContext ApplicationContext}. * * <p>This class will cache contexts based on a <i>context key</i>: normally the * config locations String array describing the Spring resource descriptors making * up the context. Unless the {@link #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. * * <p>For such standard usage, simply override the {@link #getConfigLocations()} * method and provide the desired config files. * * <p>If you don't want to load a standard context from an array of config locations, * you can override the {@link #contextKey()} method. In conjunction with this you * typically need to override the {@link #loadContext(Object)} method, which by * default loads the locations specified in the {@link #getConfigLocations()} method. * * <p><b>WARNING:</b> When doing integration tests from within Eclipse, only use * classpath resource URLs. Else, you may see misleading failures when changing * context locations. * * @author Juergen Hoeller * @author Rod Johnson * @since 2.0 * @see #getConfigLocations() * @see #contextKey() * @see #loadContext(Object) * @see #getApplicationContext() */ public abstract class AbstractSingleSpringContextTests extends AbstractSpringContextTests { /** Application context this test will run against */ protected ConfigurableApplicationContext applicationContext; private int loadCount = 0; /** * Default constructor for AbstractDependencyInjectionSpringContextTests. */ public AbstractSingleSpringContextTests() { } /** * This implementation is final. * Override <code>onSetUp</code> for custom behavior. * @see #onSetUp() */ @BeforeMethod(groups = "spring-init") protected final void setUp() throws Exception { this.applicationContext = getContext(contextKey()); prepareTestInstance(); onSetUp(); } /** * Prepare this test instance, for example populating its fields. * The context has already been loaded at the time of this callback. * <p>This implementation does nothing. */ protected void prepareTestInstance() throws Exception { } /** * Subclasses can override this method in place of the * <code>setUp()</code> method, which is final in this class. * This implementation does nothing. * @throws Exception simply let any exception propagate */ protected void onSetUp() throws Exception { } /** * 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). */ protected void setDirty() { setDirty(contextKey()); } /** * This implementation is final. * Override <code>onTearDown</code> for custom behavior. * @see #onTearDown() */ @AfterMethod(groups = "spring-init") protected final void tearDown() throws Exception { onTearDown(); } /** * Subclasses can override this to add custom behavior on teardown. * @throws Exception simply let any exception propagate */ protected void onTearDown() throws Exception { } /** * Return a key for this context. Default is the config location array * as determined by {@link #getConfigLocations()}. * <p>If you override this method, you will typically have to override * {@link #loadContext(Object)} as well, being able to handle the key type * that this method returns. * @see #getConfigLocations() */ protected Object contextKey() { return getConfigLocations(); } /** * This implementation assumes a key of type String array and loads * a context from the given locations. * <p>If you override {@link #contextKey()}, you will typically have to * override this method as well, being able to handle the key type * that <code>contextKey()</code> returns. * @see #getConfigLocations() */ protected ConfigurableApplicationContext loadContext(Object key) throws Exception { return loadContextLocations((String[]) key); } /** * Subclasses must implement this method to return the locations of their * config files, unless they override {@link #contextKey()} and * {@link #loadContext(Object)} instead. * <p>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. * <p>The default implementation returns an empty array. * @return an array of config locations */ protected String[] getConfigLocations() { return new String[0]; } /** * Load an ApplicationContext from the given config locations. * @param locations the config locations * @return the corresponding ApplicationContext instance (potentially cached) */ protected ConfigurableApplicationContext loadContextLocations(String[] locations) throws Exception { ++this.loadCount; if (logger.isInfoEnabled()) { logger.info("Loading context for: " + StringUtils.arrayToCommaDelimitedString(locations)); } return new ClassPathXmlApplicationContext(locations); } /** * Return the ApplicationContext that this base class manages. */ public final ConfigurableApplicationContext getApplicationContext() { return this.applicationContext; } /** * Return the current number of context load attempts. */ public final int getLoadCount() { return this.loadCount; } }