Tomcat Context JUnit @Rule

A first draft of a JUnit @Rule that create the test context. This can be used with the Spring context rule for this post to create a complete Spring context for integration tests.

import org.apache.commons.dbcp.BasicDataSource;
import org.apache.log4j.Logger;
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.lang.reflect.Method;
import java.sql.Driver;
import java.sql.DriverManager;
 * Creates an context for tests using an Apache Tomcat server.xml.
 * @author alex.collins
public class TomcatContextRule implements TestRule {
    public static final Logger LOGGER = Logger.getLogger(CatalinaContextRule.class);
     * Creates all the sub-contexts for a name.
    public static void createSubContexts(Context ctx, String name) {
        String subContext = '';
        for (String x : name.substring(0, name.lastIndexOf('/')).split('/')) {
            subContext += x;
            try {
            } catch (NamingException e) {
                // nop
            subContext += '/';
    private final File serverXml;
    public TomcatContextRule(File serverXml, Object target) {
        if (serverXml == null || !serverXml.isFile()) {throw new IllegalArgumentException();}
        if (target == null) {throw new IllegalArgumentException();}
        this.serverXml = serverXml;
    public Statement apply(final Statement statement, Description description) {
        return new Statement() {
            public void evaluate() throws Throwable {
                try {
                } finally {
    private void createInitialContext() throws Exception {
'creating context');
        System.setProperty(Context.URL_PKG_PREFIXES, 'org.apache.naming');
        final InitialContext ic = new InitialContext();
        createSubContexts(ic, 'java:/comp/env');
        final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        final DocumentBuilder builder = factory.newDocumentBuilder();
        final Document document = builder.parse(serverXml);
        // create Environment
            final NodeList envs = document.getElementsByTagName('Environment');
            for (int i = 0; i < envs.getLength(); i++) {
                final Element env = (Element)envs.item(i); // must be Element
                final String name = 'java:comp/env/' + env.getAttribute('name');
                final Object instance = Class.forName(env.getAttribute('type')).getConstructor(String.class)
      'binding ' + name + ' <' + instance + '>');
                createSubContexts(ic, name);
                ic.bind(name, instance);
        // Resource
            final NodeList resources = document.getElementsByTagName('Resource');
            for (int i = 0; i < resources.getLength(); i++) {
                final Element resource = (Element)resources.item(i); // must be Element
                final String name = 'java:comp/env/' + resource.getAttribute('name');
                final Class<?> type = Class.forName(resource.getAttribute('type'));
                final Object instance;
                if (type.equals(DataSource.class)) {
                        @SuppressWarnings('unchecked') // this mus be driver?
                        final Class<? extends Driver> driverClass = (Class<? extends Driver>) Class.forName(resource.getAttribute('driverClassName'));
                    final BasicDataSource dataSource = new BasicDataSource();
                    // find all the bean attributes and set them use some reflection
                    for (Method method : dataSource.getClass().getMethods()) {
                        if (!method.getName().matches('^set.*')) {continue;}
                        final String x = method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4);
                        if (!resource.hasAttribute(x)) {continue;}
                        Class<?> y = method.getParameterTypes()[0]; // might be primitive
                        if (y.isPrimitive()) {
                            if (y.getName().equals('boolean')) y = Boolean.class;
                            if (y.getName().equals('byte')) y = Byte.class;
                            if (y.getName().equals('char')) y = Character.class;
                            if (y.getName().equals('double')) y = Double.class;
                            if (y.getName().equals('float')) y = Float.class;
                            if (y.getName().equals('int')) y = Integer.class;
                            if (y.getName().equals('long')) y = Long.class;
                            if (y.getName().equals('short')) y = Short.class;
                            if (y.getName().equals('void')) y = Void.class;
                        method.invoke(dataSource, y.getConstructor(String.class).newInstance(resource.getAttribute(x)));
                    instance = dataSource;
                } else {
                    // not supported, yet...
                    throw new AssertionError('type ' + type + ' not supported');
      'binding ' + name + ' <' + instance + '>');
                createSubContexts(ic, name);
                ic.bind(name, instance);
    private void destroyInitialContext() {
'context destroyed');

For example:

    public TestRule rules = RuleChain.outerRule(new CatalinaContextRule(new File(getClass().getResource('/server.xml').getFile()), this))
            .around(new ContextRule(new String[] {'/applicationContext.xml'}, this));

This code is on Github.

Reference: Tomcat Context JUnit @Rule from our JCG partner Alex Collins at the Alex Collins ‘s blog blog.

Related Whitepaper:

Functional Programming in Java: Harnessing the Power of Java 8 Lambda Expressions

Get ready to program in a whole new way!

Functional Programming in Java will help you quickly get on top of the new, essential Java 8 language features and the functional style that will change and improve your code. This short, targeted book will help you make the paradigm shift from the old imperative way to a less error-prone, more elegant, and concise coding style that’s also a breeze to parallelize. You’ll explore the syntax and semantics of lambda expressions, method and constructor references, and functional interfaces. You’ll design and write applications better using the new standards in Java 8 and the JDK.

Get it Now!  

Leave a Reply

− 1 = eight

Java Code Geeks and all content copyright © 2010-2014, Exelixis Media Ltd | Terms of Use | Privacy Policy
All trademarks and registered trademarks appearing on Java Code Geeks are the property of their respective owners.
Java is a trademark or registered trademark of Oracle Corporation in the United States and other countries.
Java Code Geeks is not connected to Oracle Corporation and is not sponsored by Oracle Corporation.

Sign up for our Newsletter

20,709 insiders are already enjoying weekly updates and complimentary whitepapers! Join them now to gain exclusive access to the latest news in the Java world, as well as insights about Android, Scala, Groovy and other related technologies.

As an extra bonus, by joining you will get our brand new e-books, published by Java Code Geeks and their JCG partners for your reading pleasure! Enter your info and stay on top of things,

  • Fresh trends
  • Cases and examples
  • Research and insights
  • Two complimentary e-books