package com.flexiblewebsolutions.xdriveunit;
   
   import java.io.File;
   import java.io.FileNotFoundException;
   import java.util.HashMap;
   
   import junit.framework.Test;
   import junit.framework.TestCase;
   
  import org.apache.log4j.Logger;
  
  import com.flexiblewebsolutions.exceptions.MissingConfigException;
  import com.flexiblewebsolutions.io.util.FileUtils;
  import com.flexiblewebsolutions.xml.util.XMLStringParser;
  
  /***
   * A TestCase implementation that uses XML files to drive test behavior
   * 
   * @author Donavon Buss
   */
  public abstract class XDriveTestCase extends TestCase implements
          XDriveTest
  {
      static Logger logger = Logger.getLogger( XDriveTestCase.class.getName() );
  
      /***
       * Data that will be available to test methods during execution.
       */
      protected StringBuffer _TestInput = null;
  
      /***
       * Name of thread for differentiating test instances.
       */
      protected String _ThreadName = null;
  
      /***
       * Define behavior of test based on options
       */
      private HashMap _TestOptions = null;
  
      /***
       * Init the web client test case
       * 
       * @param pName -
       *            Name of test to be run
       * @param pTestInput -
       *            data needed for input during test
       * @param pTestOptions -
       *            different options that control behavior of all tests
       * @param pTheadName -
       *            User supplied name of thread running test
       */
      public XDriveTestCase( String pName, StringBuffer pTestInput,
              StringBuffer pTestOptions, String pThreadName )
      {
          super( pName );
          _TestInput = pTestInput;
  
          if( pTestOptions != null )
          {
              setupTestOptions( pTestOptions );
          }
          _ThreadName = pThreadName;
      }
      
      protected HashMap getTestOptions()
      {
          if( _TestOptions == null )
          {
              _TestOptions = new HashMap();
          }
          return( _TestOptions );
      }
  
      /***
       * Internal method only. Needed for loading parameters for test lookup.
       *  
       */
      protected XDriveTestCase()
      {
          super();
      }
  
      /***
       * Parse out the passed in xml string for different options to be applied to
       * all tests
       * 
       * @param pTestOptions -
       *            xml containing test options
       */
      protected void setupTestOptions( StringBuffer pTestOptions )
      {
          logger.debug( "setupTestOptions" );
          String testOptions = XMLStringParser.getValueForTag( pTestOptions,
                  "testOptions" );
          if( testOptions != null )
          {
              // Get the variables that are set in the xml file
              String[] variables = XMLStringParser.getMatchingNestedTags(
                     testOptions, "testVariable" );
             // this hashmap will be home to the test options
             _TestOptions = new HashMap( variables.length );
 
             for( int i = 0; i < variables.length; i++ )
             {
                 StringBuffer variableData = new StringBuffer( variables[i] );
                 String varName = XMLStringParser.getValueForTag( variableData,
                         "name" );
                 // value can be true/false or an entire XML string (as long as
                 // it does not contain the tag <value> )
                 String varVal = XMLStringParser.getValueForTag( variableData,
                         "value" );
                 _TestOptions.put( varName, varVal );
             }
             variables = null;
         }
     }
 
     /***
      * Retrieve property from Map and return it's boolean value
      * 
      * @param pPropName
      * @return true or false
      */
     protected boolean checkBooleanParameter( String pPropName )
     {
         boolean returnVal = false;
         String val = (String) getTestOptions().get( pPropName );
 
         if( val != null && val.equalsIgnoreCase( "true" ) )
         {
             returnVal = true;
         }
         else
         {
             returnVal = false;
         }
         val = null;
         return ( returnVal );
     }
 
     /***
      * Creates the test suite using an XML configuration file.
      * 
      * @param pConfigFile -
      *            Relative path of file from TestDirectory setting or current
      *            directory
      * @return TestSuite
      */
     protected Test init( String pConfigFile ) throws MissingConfigException
     {
         if( pConfigFile == null )
         {
             logger.error( "Path to configuration file was not specified." );
             throw new MissingConfigException(
                     "Path to configuration file was not specified." );
         }
         try
         {
             File configFile = getFile( pConfigFile );
             FileUtils fu = new FileUtils();
             StringBuffer configText = fu.loadXMLFileToString( configFile );
             return ( init( configText, "" ) );
         }
         catch( FileNotFoundException e )
         {
             logger.error( e.getMessage(), e );
             throw new MissingConfigException( e.getMessage() );
         }
     }
 
     /***
      * Attempts to load requested file from getTestDirectory and then from the
      * current directory
      * 
      * @param pFilePath -
      *            relative path to file
      * @return Path to the located file
      * @throws FileNotFoundException
      */
     protected File getFile( String pFilePath ) throws FileNotFoundException
     {
         File returnFile = null;
         File testDirFile = new File( getTestDirectory(), pFilePath );
         if( !testDirFile.exists() )
         {
             File thisDirFile = new File( pFilePath );
             if( !testDirFile.exists() )
             {
                 throw new FileNotFoundException( "Could not find file in "
                         + testDirFile.getAbsolutePath() + " or "
                         + thisDirFile.getAbsolutePath() );
             }
             else
             {
                 returnFile = thisDirFile;
             }
             thisDirFile = null;
         }
         else
         {
             returnFile = testDirFile;
         }
         testDirFile = null;
         return ( returnFile );
     }
 
     /***
      * Builds a test suite based on a configuration String.
      * 
      * @param pConfigInfo
      *            StringBuffer which contains XML configuration for the test.
      * @param pThreadName
      *            Name to be used to differeniate different threads running same
      *            test.
      * @return Suite of tests to be run.
      */
     protected Test init( StringBuffer pConfigInfo, String pThreadName )
     {
         TestSuiteLoader tsl = new TestSuiteLoader();
         Test returnSuite = null;
 
         try
         {
             returnSuite = tsl.buildSuite( pConfigInfo, pThreadName,
                     getClassName(), getTestDirectory() );
         }
         catch( FileNotFoundException e )
         {
             logger.error( "Could not load configuration info from " + pConfigInfo, e );
             e.printStackTrace();
         }
         return ( returnSuite );
     }
 }