/*

  * Copyright 2007 The Kuali Foundation

  * 

  * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php

  * 

  * 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.kuali.rice.test;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.HashSet;

 import java.util.LinkedList;

 import java.util.List;

 import java.util.ListIterator;

 import java.util.Properties;

 import java.util.Set;

 import javax.xml.namespace.QName;

 import org.apache.commons.lang.StringUtils;

 import org.apache.log4j.Logger;

 import org.apache.log4j.PropertyConfigurator;

 import org.junit.After;

 import org.junit.Before;

 import org.kuali.rice.core.api.config.property.Config;

 import org.kuali.rice.core.api.config.property.ConfigContext;

 import org.kuali.rice.core.api.lifecycle.BaseLifecycle;

 import org.kuali.rice.core.api.lifecycle.Lifecycle;

 import org.kuali.rice.core.impl.config.property.JAXBConfigImpl;

 import org.kuali.rice.core.framework.resourceloader.SpringResourceLoader;

 import org.kuali.rice.test.data.PerSuiteUnitTestData;

 import org.kuali.rice.test.lifecycles.PerSuiteDataLoaderLifecycle;

 import org.springframework.core.io.FileSystemResourceLoader;

 import org.springframework.core.io.Resource;

 import org.springframework.core.io.ResourceLoader;

 /**

  * Useful superclass for all Rice test cases. Handles setup of test utilities and a test environment. Configures the

  * Spring test environment providing a template method for custom context files in test mode. Also provides a template method

  * for running custom transactional setUp. Tear down handles automatic tear down of objects created inside the test

  * environment.

  * 

  * @author Kuali Rice Team (rice.collab@kuali.org)

  * @since 0.9

  */

 public abstract class RiceTestCase extends BaseRiceTestCase {

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

     private static final String ALT_LOG4J_CONFIG_LOCATION_PROP = "alt.log4j.config.location";

     private static final String DEFAULT_LOG4J_CONFIG = "classpath:rice-testharness-default-log4j.properties";

     protected static final String DEFAULT_TEST_HARNESS_SPRING_BEANS = "classpath:TestHarnessSpringBeans.xml";

     protected static boolean SUITE_LIFE_CYCLES_RAN = false;

     protected static boolean SUITE_LIFE_CYCLES_FAILED = false;

     protected static String failedSuiteTestName;

     protected List<Lifecycle> perTestLifeCycles = new LinkedList<Lifecycle>();

     protected List<Lifecycle> suiteLifeCycles = new LinkedList<Lifecycle>();

     private static Set<String> perSuiteDataLoaderLifecycleNamesRun = new HashSet<String>();

     private List<String> reports = new ArrayList<String>();

     private SpringResourceLoader testHarnessSpringResourceLoader;

     @Before

     public void setUp() throws Exception {

         try {

             configureLogging();

             logBeforeRun();

             final long initTime = System.currentTimeMillis();

             setUpInternal();

             report("Time to start all Lifecycles: " + (System.currentTimeMillis() - initTime));

         } catch (Throwable e) {

             e.printStackTrace();

             tearDown();

             throw new RuntimeException(e);

         }

     }

     /**

      * Internal setUp() implementation which is invoked by the main setUp() and wrapped

      * with exception handling.  Subclasses should override this method if they want to

      * add set up steps that should occur in the standard set up process, wrapped by

      * exception handling.

      */

     protected void setUpInternal() throws Exception {

         assertNotNull(getModuleName());

         setModuleName(getModuleName());

         setBaseDirSystemProperty(getModuleName());

         this.perTestLifeCycles = getPerTestLifecycles();

         this.suiteLifeCycles = getSuiteLifecycles();

         if (SUITE_LIFE_CYCLES_FAILED) {

                 fail("Suite Lifecycles startup failed on test " + failedSuiteTestName + "!!!  Please see logs for details.");

         }

         if (!SUITE_LIFE_CYCLES_RAN) {

                 try {

                     startLifecycles(this.suiteLifeCycles);

                     SUITE_LIFE_CYCLES_RAN = true;

                 } catch (Throwable e) {

                         e.printStackTrace();

                 SUITE_LIFE_CYCLES_RAN = false;

                 SUITE_LIFE_CYCLES_FAILED = true;

                 failedSuiteTestName = getFullTestName();

                 tearDown();

                 stopLifecycles(this.suiteLifeCycles);

                 throw new RuntimeException(e);

             }

         }

         startSuiteDataLoaderLifecycles();

         startLifecycles(this.perTestLifeCycles);

     }

     /**

      * This block is walking up the class hierarchy of the current unit test looking for PerSuiteUnitTestData annotations. If it finds one,

      * it will run it once, then add it to a set so that it does not get run again. This is needed so that multiple 

      * tests can extend from the same suite and so that there can be multiple suites throughout the test source branch.

      * 

      * @throws Exception if a PerSuiteDataLoaderLifecycle is unable to be started

      */

     protected void startSuiteDataLoaderLifecycles() throws Exception {

         List<Class> classes = TestUtilities.getHierarchyClassesToHandle(getClass(), new Class[] { PerSuiteUnitTestData.class }, perSuiteDataLoaderLifecycleNamesRun);

         for (Class c: classes) {

             new PerSuiteDataLoaderLifecycle(c).start();

             perSuiteDataLoaderLifecycleNamesRun.add(c.getName());

         }

     }

     /**

      * maven will set this property and find resources from the config based on it. This makes eclipse testing work because

      * we have to put the basedir in our config files in order to find things when testing from maven

      */

     protected void setBaseDirSystemProperty(String moduleBaseDir) {

         if (System.getProperty("basedir") == null) {

             System.setProperty("basedir", System.getProperty("user.dir") + "/" + moduleBaseDir);

         }

     }

     /**

      * Returns the basedir for the module under which the tests are currently executing.

      */

     protected String getBaseDir() {

         return System.getProperty("basedir");

     }

     protected void setModuleName(String moduleName) {

         if (System.getProperty("module.name") == null) {

             System.setProperty("module.name", moduleName);

         }

     }

     @After

     public void tearDown() throws Exception {

             // wait for outstanding threads to complete for 1 minute

             ThreadMonitor.tearDown(60000);

         stopLifecycles(this.perTestLifeCycles);

         logAfterRun();

     }

     protected void logBeforeRun() {

         LOG.info("##############################################################");

         LOG.info("# Starting test " + getFullTestName() + "...");

         LOG.info("# " + dumpMemory());

         LOG.info("##############################################################");

     }

     protected void logAfterRun() {

         LOG.info("##############################################################");

         LOG.info("# ...finished test " + getFullTestName());

         LOG.info("# " + dumpMemory());

         for (final String report : this.reports) {

             LOG.info("# " + report);

         }

         LOG.info("##############################################################\n\n\n");

     }

     protected String getFullTestName() {

             return getClass().getSimpleName() + "." + getName();

     }

         protected void configureLogging() throws IOException {

         ResourceLoader resourceLoader = new FileSystemResourceLoader();

         String altLog4jConfigLocation = System.getProperty(ALT_LOG4J_CONFIG_LOCATION_PROP);

         Resource log4jConfigResource = null;

         if (!StringUtils.isEmpty(altLog4jConfigLocation)) { 

             log4jConfigResource = resourceLoader.getResource(altLog4jConfigLocation);

         }

         if (log4jConfigResource == null || !log4jConfigResource.exists()) {

             System.out.println("Alternate Log4j config resource does not exist! " + altLog4jConfigLocation);

             System.out.println("Using default log4j configuration: " + DEFAULT_LOG4J_CONFIG);

             log4jConfigResource = resourceLoader.getResource(DEFAULT_LOG4J_CONFIG);

         } else {

             System.out.println("Using alternate log4j configuration at: " + altLog4jConfigLocation);

         }

         Properties p = new Properties();

         p.load(log4jConfigResource.getInputStream());

         PropertyConfigurator.configure(p);

     }

         /**

          * Executes the start() method of each of the lifecycles in the given list.

          */

     protected void startLifecycles(List<Lifecycle> lifecycles) throws Exception {

         for (Lifecycle lifecycle : lifecycles) {

             lifecycle.start();

         }

     }

     /**

      * Executes the stop() method of each of the lifecyles in the given list.  The

      * List of lifecycles is processed in reverse order.

      */

     protected void stopLifecycles(List<Lifecycle> lifecycles) throws Exception {

         final ListIterator<Lifecycle> iter = lifecycles.listIterator();

         while (iter.hasNext()) {

             iter.next();

         }

         while (iter.hasPrevious()) {

             final Lifecycle lifeCycle = iter.previous();

             try {

                     if (lifeCycle == null) {

                             LOG.warn("Attempted to stop a null lifecycle");

                     } else {

                             if (lifeCycle.isStarted()) {

                                     lifeCycle.stop();

                             }

                     }

             } catch (Exception e) {

                 LOG.warn("Failed to shutdown one of the lifecycles!", e);

             }

         }

     }

     /**

      * Returns the List of Lifecycles to start when the unit test suite is started

      */

     protected List<Lifecycle> getSuiteLifecycles() {

         List<Lifecycle> lifecycles = new LinkedList<Lifecycle>();

         /**

          * Initializes Rice configuration from the test harness configuration file.

          */

         lifecycles.add(new BaseLifecycle() {

             public void start() throws Exception {

                 Config config = getTestHarnessConfig();

                 ConfigContext.init(config);

                 super.start();

             }

         });

         /**

          * Loads the TestHarnessSpringBeans.xml file which obtains connections to the DB for us

          */

         lifecycles.add(getTestHarnessSpringResourceLoader());

         /**

          * Establishes the TestHarnessServiceLocator so that it has a reference to the Spring context

          * created from TestHarnessSpringBeans.xml

          */

         lifecycles.add(new BaseLifecycle() {

             public void start() throws Exception {

                 TestHarnessServiceLocator.setContext(getTestHarnessSpringResourceLoader().getContext());

                 super.start();

             }

         });

         /**

          * Clears the tables in the database.

          */

         lifecycles.add(new ClearDatabaseLifecycle());

         /**

          * Loads Suite Test Data

          */

         lifecycles.add(new BaseLifecycle() {

                 public void start() throws Exception {

                         loadSuiteTestData();

                         super.start();

                 }

         });

         Lifecycle loadApplicationLifecycle = getLoadApplicationLifecycle();

         if (loadApplicationLifecycle != null) {

                 lifecycles.add(loadApplicationLifecycle);

         }

         return lifecycles;

     }

     /**

      * This should return a Lifecycle that can be used to load the application

      * being tested.  For example, this could start a Jetty Server which loads

      * the application, or load a Spring context to establish a set of services,

      * or any other application startup activities that the test depends upon.

      */

     protected Lifecycle getLoadApplicationLifecycle() {

             // by default return null, do nothing

             return null;

     }

     /**

      * @return Lifecycles run every test run

      */

     protected List<Lifecycle> getPerTestLifecycles() {

             List<Lifecycle> lifecycles = new LinkedList<Lifecycle>();

             if (getClass().isAnnotationPresent(TransactionalTest.class)) {

                     String transactionManagerName = getClass().getAnnotation(TransactionalTest.class).transactionManager();

                         TransactionalLifecycle transactionalLifecycle = new TransactionalLifecycle(transactionManagerName);

                         lifecycles.add(transactionalLifecycle);

                 }

         lifecycles.add(getPerTestDataLoaderLifecycle());

         lifecycles.add(new BaseLifecycle() {

             public void start() throws Exception {

                 loadPerTestData();

                 super.start();

             }

         });

         return lifecycles;

     }

     /**

      * A method that can be overridden to load test data for the unit test Suite.

      */

     protected void loadSuiteTestData() throws Exception {

             // do nothing by default, subclass can override

     }

     /**

      * A method that can be overridden to load test data on a test-by-test basis

      */

     protected void loadPerTestData() throws Exception {

             // do nothing by default, subclass can override

     }

     protected void report(final String report) {

         this.reports.add(report);

     }

     protected String dumpMemory() {

         final long total = Runtime.getRuntime().totalMemory();

         final long free = Runtime.getRuntime().freeMemory();

         final long max = Runtime.getRuntime().maxMemory();

         return "[Memory] max: " + max + ", total: " + total + ", free: " + free;

     }

     public SpringResourceLoader getTestHarnessSpringResourceLoader() {

         if (testHarnessSpringResourceLoader == null) {

             testHarnessSpringResourceLoader = new SpringResourceLoader(new QName("TestHarnessSpringContext"), getTestHarnessSpringBeansLocation(), null);

         }

         return testHarnessSpringResourceLoader;

     }

     /**

      * Returns the location of the test harness spring beans context file.

      * Subclasses may override to specify a different location.

      * @return the location of the test harness spring beans context file.

      */

     protected String getTestHarnessSpringBeansLocation() {

         return DEFAULT_TEST_HARNESS_SPRING_BEANS;

     }

     protected Config getTestHarnessConfig() throws Exception {

         Config config = new JAXBConfigImpl(getConfigLocations(), System.getProperties());

         config.parseConfig();

         return config;

     }

     /**

      * Subclasses may override this method to customize the location(s) of the Rice configuration.

      * By default it is: classpath:META-INF/" + getModuleName().toLowerCase() + "-test-config.xml"

      * @return List of config locations to add to this tests config location.

      */

     protected List<String> getConfigLocations() {

         List<String> configLocations = new ArrayList<String>();

         configLocations.add(getRiceMasterDefaultConfigFile());

         configLocations.add(getModuleTestConfigLocation());

         return configLocations;

     }

     protected String getModuleTestConfigLocation() {

         return "classpath:META-INF/" + getModuleName().toLowerCase() + "-test-config.xml";

     }

     protected String getRiceMasterDefaultConfigFile() {

         return "classpath:META-INF/test-config-defaults.xml";

     }

     /**

      * same as the module directory in the project.

      * 

      * @return name of module that the tests located

      */

     protected abstract String getModuleName();

 }