AbstractDependencyInjectionSpringContextTests.java :  » J2EE » spring-ide_2.3.0 » org » springframework » test » Java Open Source

Java Open Source » J2EE » spring ide_2.3.0 
spring ide_2.3.0 » org » springframework » test » AbstractDependencyInjectionSpringContextTests.java
/*
 * Copyright 2002-2008 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.springframework.test;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.LinkedList;
import java.util.List;

import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.util.Assert;

/**
 * <p>
 * Convenient superclass for JUnit 3.8 based tests depending on a Spring
 * context. The test instance itself is populated by Dependency Injection.
 * </p>
 * <p>
 * Really for integration testing, not unit testing. You should <i>not</i>
 * normally use the Spring container for unit tests: simply populate your POJOs
 * in plain JUnit tests!
 * </p>
 * <p>
 * This supports two modes of populating the test:
 * </p>
 * <ul>
 * <li>Via Setter Dependency Injection. Simply express dependencies on objects
 * in the test fixture, and they will be satisfied by autowiring by type.
 * <li>Via Field Injection. Declare protected variables of the required type
 * which match named beans in the context. This is autowire by name, rather than
 * type. This approach is based on an approach originated by Ara Abrahmian.
 * Setter Dependency Injection is the default: set the
 * <code>populateProtectedVariables</code> property to <code>true</code> in
 * the constructor to switch on Field Injection.
 * </ul>
 *
 * @author Rod Johnson
 * @author Rob Harrop
 * @author Rick Evans
 * @author Sam Brannen
 * @since 1.1.1
 * @see #setDirty
 * @see #contextKey
 * @see #getContext
 * @see #getConfigLocations
 */
public abstract class AbstractDependencyInjectionSpringContextTests extends AbstractSingleSpringContextTests {

  /**
   * Constant that indicates no autowiring at all.
   *
   * @see #setAutowireMode
   */
  public static final int AUTOWIRE_NO = 0;

  /**
   * Constant that indicates autowiring bean properties by name.
   *
   * @see #setAutowireMode
   */
  public static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME;

  /**
   * Constant that indicates autowiring bean properties by type.
   *
   * @see #setAutowireMode
   */
  public static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE;

  private boolean populateProtectedVariables = false;

  private int autowireMode = AUTOWIRE_BY_TYPE;

  private boolean dependencyCheck = true;

  private String[] managedVariableNames;


  /**
   * Default constructor for AbstractDependencyInjectionSpringContextTests.
   */
  public AbstractDependencyInjectionSpringContextTests() {
  }

  /**
   * Constructor for AbstractDependencyInjectionSpringContextTests with a
   * JUnit name.
   * @param name the name of this text fixture
   */
  public AbstractDependencyInjectionSpringContextTests(String name) {
    super(name);
  }


  /**
   * Set whether to populate protected variables of this test case. Default is
   * <code>false</code>.
   */
  public final void setPopulateProtectedVariables(boolean populateFields) {
    this.populateProtectedVariables = populateFields;
  }

  /**
   * Return whether to populate protected variables of this test case.
   */
  public final boolean isPopulateProtectedVariables() {
    return this.populateProtectedVariables;
  }

  /**
   * Set the autowire mode for test properties set by Dependency Injection.
   * <p>The default is {@link #AUTOWIRE_BY_TYPE}. Can be set to
   * {@link #AUTOWIRE_BY_NAME} or {@link #AUTOWIRE_NO} instead.
   * @see #AUTOWIRE_BY_TYPE
   * @see #AUTOWIRE_BY_NAME
   * @see #AUTOWIRE_NO
   */
  public final void setAutowireMode(final int autowireMode) {
    this.autowireMode = autowireMode;
  }

  /**
   * Return the autowire mode for test properties set by Dependency Injection.
   */
  public final int getAutowireMode() {
    return this.autowireMode;
  }

  /**
   * Set whether or not dependency checking should be performed for test
   * properties set by Dependency Injection.
   * <p>The default is <code>true</code>, meaning that tests cannot be run
   * unless all properties are populated.
   */
  public final void setDependencyCheck(final boolean dependencyCheck) {
    this.dependencyCheck = dependencyCheck;
  }

  /**
   * Return whether or not dependency checking should be performed for test
   * properties set by Dependency Injection.
   */
  public final boolean isDependencyCheck() {
    return this.dependencyCheck;
  }

  /**
   * Prepare this test instance, injecting dependencies into its protected
   * fields and its bean properties.
   * <p>Note: if the {@link ApplicationContext} for this test instance has not
   * been configured (e.g., is <code>null</code>), dependency injection
   * will naturally <strong>not</strong> be performed, but an informational
   * message will be written to the log.
   * @see #injectDependencies()
   */
  protected void prepareTestInstance() throws Exception {
    if (getApplicationContext() == null) {
      if (this.logger.isInfoEnabled()) {
        this.logger.info("ApplicationContext has not been configured for test [" + getClass().getName()
            + "]: dependency injection will NOT be performed.");
      }
    }
    else {
      injectDependencies();
    }
  }

  /**
   * Inject dependencies into 'this' instance (that is, this test instance).
   * <p>The default implementation populates protected variables if the
   * {@link #populateProtectedVariables() appropriate flag is set}, else uses
   * autowiring if autowiring is switched on (which it is by default).
   * <p>Override this method if you need full control over how dependencies are
   * injected into the test instance.
   * @throws Exception in case of dependency injection failure
   * @throws IllegalStateException if the {@link ApplicationContext} for this
   * test instance has not been configured
   * @see #populateProtectedVariables()
   */
  protected void injectDependencies() throws Exception {
    Assert.state(getApplicationContext() != null,
        "injectDependencies() called without first configuring an ApplicationContext");
    if (isPopulateProtectedVariables()) {
      if (this.managedVariableNames == null) {
        initManagedVariableNames();
      }
      populateProtectedVariables();
    }
    getApplicationContext().getBeanFactory().autowireBeanProperties(this, getAutowireMode(), isDependencyCheck());
  }

  private void initManagedVariableNames() throws IllegalAccessException {
    List managedVarNames = new LinkedList();
    Class clazz = getClass();
    do {
      Field[] fields = clazz.getDeclaredFields();
      if (this.logger.isDebugEnabled()) {
        this.logger.debug("Found " + fields.length + " fields on " + clazz);
      }
      for (int i = 0; i < fields.length; i++) {
        Field field = fields[i];
        field.setAccessible(true);
        if (this.logger.isDebugEnabled()) {
          this.logger.debug("Candidate field: " + field);
        }
        if (isProtectedInstanceField(field)) {
          Object oldValue = field.get(this);
          if (oldValue == null) {
            managedVarNames.add(field.getName());
            if (this.logger.isDebugEnabled()) {
              this.logger.debug("Added managed variable '" + field.getName() + "'");
            }
          }
          else {
            if (this.logger.isDebugEnabled()) {
              this.logger.debug("Rejected managed variable '" + field.getName() + "'");
            }
          }
        }
      }
      clazz = clazz.getSuperclass();
    } while (!clazz.equals(AbstractDependencyInjectionSpringContextTests.class));

    this.managedVariableNames = (String[]) managedVarNames.toArray(new String[managedVarNames.size()]);
  }

  private boolean isProtectedInstanceField(Field field) {
    int modifiers = field.getModifiers();
    return !Modifier.isStatic(modifiers) && Modifier.isProtected(modifiers);
  }

  private void populateProtectedVariables() throws IllegalAccessException {
    for (int i = 0; i < this.managedVariableNames.length; i++) {
      String varName = this.managedVariableNames[i];
      Object bean = null;
      try {
        Field field = findField(getClass(), varName);
        bean = getApplicationContext().getBean(varName, field.getType());
        field.setAccessible(true);
        field.set(this, bean);
        if (this.logger.isDebugEnabled()) {
          this.logger.debug("Populated field: " + field);
        }
      }
      catch (NoSuchFieldException ex) {
        if (this.logger.isWarnEnabled()) {
          this.logger.warn("No field with name '" + varName + "'");
        }
      }
      catch (NoSuchBeanDefinitionException ex) {
        if (this.logger.isWarnEnabled()) {
          this.logger.warn("No bean with name '" + varName + "'");
        }
      }
    }
  }

  private Field findField(Class clazz, String name) throws NoSuchFieldException {
    try {
      return clazz.getDeclaredField(name);
    }
    catch (NoSuchFieldException ex) {
      Class superclass = clazz.getSuperclass();
      if (superclass != AbstractSpringContextTests.class) {
        return findField(superclass, name);
      }
      else {
        throw ex;
      }
    }
  }

}
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.