/*

  * Copyright 2009, Josh Devins, Jitr.org.

  *

  * 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.jitr;

 import java.lang.reflect.Constructor;

 import java.lang.reflect.Field;

 import java.lang.reflect.Modifier;

 import java.util.Collection;

 import java.util.Iterator;

 import java.util.LinkedList;

 import javax.servlet.ServletContext;

 import org.apache.log4j.Logger;

 import org.jitr.annotation.BaseUri;

 import org.jitr.annotation.JitrConfiguration;

 import org.jitr.annotation.Port;

 import org.jitr.core.ConfigurationModel;

 import org.jitr.core.Container;

 import org.jitr.core.JitrException;

 import org.jitr.core.OperationalMode;

 import org.junit.internal.runners.ClassRoadie;

 import org.junit.internal.runners.InitializationError;

 import org.junit.internal.runners.JUnit4ClassRunner;

 import org.junit.runner.notification.RunNotifier;

 import org.springframework.beans.factory.config.AutowireCapableBeanFactory;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import org.springframework.core.annotation.AnnotationUtils;

 import org.springframework.test.context.ContextConfiguration;

 import org.springframework.test.context.ContextLoader;

 import org.springframework.web.context.WebApplicationContext;

 import org.springframework.web.context.support.WebApplicationContextUtils;

 /**

  * The heart of Jitr. This provides all of the configuration, Spring application context loading,

  * bootstrapping and wiring of test classes.

  * 

  * @author Josh Devins (info@joshdevins.net)

  */

 @JitrConfiguration

 public final class Jitr extends JUnit4ClassRunner {

     private static final Logger LOG = Logger.getLogger(Jitr.class);

     private ConfigurationModel config;

     private Container<?> container;

     private AutowireCapableBeanFactory autowireCapableBeanFactory;

     public Jitr(final Class<?> clazz) throws InitializationError {

         super(clazz);

     }

     @Override

     public void run(final RunNotifier notifier) {

         if (LOG.isInfoEnabled()) {

             LOG.info("Jitr loaded");

         }

         // get the Jitr configuration (if any) from the test class

         JitrConfiguration annot =

                 AnnotationUtils.findAnnotation(getTestClass().getJavaClass(),

                         JitrConfiguration.class);

         if (LOG.isInfoEnabled() && annot == null) {

             LOG.info("No @JitrConfiguration found on test class");

         }

         config = JitrConfigurationFactory.createConfigurationFromAnnotation(annot);

         if (config == null) {

             throw new JitrException("Configuration could not be created.");

         }

         final ServletContext servletContext = initAndStartContainerIfNeeded();

         // setup Spring if we can

         setSpringAutowireCapableBeanFactory(servletContext);

         // create JUnit class roadie for running tests

         final ClassRoadie roadie =

                 new ClassRoadie(notifier, getTestClass(), getDescription(), new Runnable() {

                     public void run() {

                         runMethods(notifier);

                     }

                 });

         if (LOG.isInfoEnabled()) {

             LOG.info("Running tests");

         }

         // run tests regularly with JUnit class roadie

         roadie.runProtected();

         if (config.getMode().isContainerEnabled()) {

             if (LOG.isInfoEnabled()) {

                 LOG.info("Stopping container: " + container.getName());

             }

             container.stop();

         }

     }

     @Override

     protected Object createTest() throws Exception {

         Object testInstance = super.createTest();

         // autowire the test if we can

         if (autowireCapableBeanFactory != null) {

             autowireCapableBeanFactory.autowireBean(testInstance);

         }

         // set @Port field

         final Field portField =

                 JitrUtils.getMostSpecificAnnotatedDeclaredField(testInstance.getClass(), Port.class);

         if (portField != null) {

             validateModifiersAndSetAccessible(portField, "Port");

             portField.setInt(testInstance, config.getPort());

         }

         // set @BaseUri field

         final Field baseUriField =

                 JitrUtils.getMostSpecificAnnotatedDeclaredField(testInstance.getClass(),

                         BaseUri.class);

         if (baseUriField != null) {

             validateModifiersAndSetAccessible(baseUriField, "BaseUri");

             baseUriField.set(testInstance, config.getBaseUri());

         }

         return testInstance;

     }

     private ServletContext initAndStartContainerIfNeeded() {

         // if the container is disabled, then we don't need to do any of this

         if (!config.getMode().isContainerEnabled()) {

             return null;

         }

         final Class<?> containerClass = config.getContainerClass();

         // try to instantiate the container implementation class

         try {

             Constructor<?> containerConstructor = containerClass.getConstructor();

             container = (Container<?>) containerConstructor.newInstance();

         } catch (final Exception e) {

             throw new JitrException("Could not instantiate Container implementation class: "

                     + containerClass.toString(), e);

         }

         if (LOG.isInfoEnabled()) {

             LOG.info("Initializing container: " + container.getName());

         }

         ServletContext servletContext =

                 container.initialize(config, getTestClass().getJavaClass().getAnnotations());

         if (LOG.isInfoEnabled()) {

             LOG.info("Starting container: " + container.getName());

         }

         container.start();

         return servletContext;

     }

     private void setSpringAutowireCapableBeanFactory(final ServletContext servletContext) {

         // using same Spring application context as webapp

         if (config.getMode() == OperationalMode.INTERNAL) {

             // load web app context from current Thread

             WebApplicationContext webApplicationContext =

                     org.springframework.web.context.ContextLoader.getCurrentWebApplicationContext();

             // sometimes Spring will be loaded in another thread, make sure we have a ServletContext

             if (webApplicationContext == null && servletContext == null) {

                 throw new JitrException(

                         "Servlet context was null and no Spring web application context could"

                                 + " be found in the current Thread.");

             }

             if (webApplicationContext == null) {

                 webApplicationContext =

                         WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);

             }

             // make sure there is a Spring web application context

             if (webApplicationContext == null) {

                 LOG.warn("No Spring web application context was found and Jitr is not configured "

                         + "to use an external Spring application context configuration.");

                 return;

             }

             autowireCapableBeanFactory = webApplicationContext.getAutowireCapableBeanFactory();

             return;

         }

         // need to load an external Spring application context configuration

         ContextConfiguration contextConfiguration =

                 AnnotationUtils.findAnnotation(getTestClass().getJavaClass(),

                         ContextConfiguration.class);

         // make sure we can find the configuration

         if (contextConfiguration == null) {

             throw new JitrException(

                     "Jitr is configured to use an external Spring application context but none"

                             + " has been configured. Use @ContextConfiguration on your test class"

                             + " to define what Spring application context configurations should"

                             + " be loaded.");

         }

         // TODO: Implement location inheritance.

         // boolean inheritLocations =

         // contextConfiguration.inheritLocations();

         Class<? extends ContextLoader> contextLoaderClass = contextConfiguration.loader();

         String[] locations = contextConfiguration.locations();

         ApplicationContext applicationContext;

         // if a ContextLoader class was specified on the annotation, use it

         if (contextLoaderClass != null && contextLoaderClass != ContextLoader.class) {

             try {

                 Constructor<? extends ContextLoader> constructor =

                         contextLoaderClass.getConstructor();

                 ContextLoader contextLoader = constructor.newInstance();

                 String[] processedLocations =

                         contextLoader.processLocations(getTestClass().getJavaClass(), locations);

                 applicationContext = contextLoader.loadContext(processedLocations);

             } catch (final Exception e) {

                 throw new JitrException("Error loading Spring application contexts.", e);

             }

         } else {

             // use a default XML context loader

             applicationContext = new ClassPathXmlApplicationContext(locations);

         }

         autowireCapableBeanFactory = applicationContext.getAutowireCapableBeanFactory();

     }

     private void validateModifiersAndSetAccessible(final Field field, final String annotationName) {

         final int modifiers = field.getModifiers();

         final Collection<String> problemModifiers = new LinkedList<String>();

         if (Modifier.isStatic(modifiers)) {

             problemModifiers.add("static");

         }

         if (Modifier.isFinal(modifiers)) {

             problemModifiers.add("final");

         }

         if (!problemModifiers.isEmpty()) {

             final Iterator<String> iterator = problemModifiers.iterator();

             final StringBuilder stringBuilder = new StringBuilder();

             while (iterator.hasNext()) {

                 stringBuilder.append(iterator.next());

                 if (iterator.hasNext()) {

                     stringBuilder.append(", ");

                 }

             }

             throw new JitrException("Field annotated with @" + annotationName + " cannot be: "

                     + stringBuilder.toString());

         }

         field.setAccessible(true);

     }

 }