/*

  * Copyright 1999-2002,2004 The Apache Software Foundation.

  * 

  * 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.apache.commons.latka;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileWriter;

 import java.io.IOException;

 import java.io.StringReader;

 import java.io.StringWriter;

 import java.net.URL;

 import java.text.SimpleDateFormat;

 import java.util.Date;

 import java.util.Iterator;

 import java.util.Properties;

 import javax.xml.transform.Source;

 import javax.xml.transform.Transformer;

 import javax.xml.transform.TransformerException;

 import javax.xml.transform.TransformerFactory;

 import javax.xml.transform.stream.StreamResult;

 import javax.xml.transform.stream.StreamSource;

 import org.apache.commons.jelly.Jelly;

 import org.apache.commons.jelly.JellyContext;

 import org.apache.commons.jelly.XMLOutput;

 import org.apache.commons.latka.event.LatkaEventInfo;

 import org.apache.commons.latka.event.LatkaEventListener;

 import org.apache.commons.latka.jelly.JellyUtils;

 import org.apache.log4j.Category;

 /**

  * This is the primary class for executing Latka functional

  * tests.  The main(String aargs[]) class provides a convenient

  * command-line interface for executing single tests.  See the

  * Latka documentation for details on command-line usage.

  * There is also a webapp-based Latka interface.

  *

  * @see Suite

  * @see LatkaProperties

  *

  * @author Morgan Delagrange

  * @author <a href="mailto:dion@apache.org">dIon Gillard</a>

  *

  * @version $Revision: 155424 $

  */

 public class Latka {

     /** whether xml parsing is validating or not */

     protected boolean _isValidating = true;

     /** XSL stylesheet url to use when generating XML */

     protected URL _reportStylesheetUrl = null;

     /** log4j category for logged output */

     protected static final Category _log = 

                              Category.getInstance(Latka.class.getName());

     /** Latka configuration variables */

     protected Properties _props = LatkaProperties.getProperties();

     /** Message displayed to user when incorrect args provided */

     private static final String LATKA_USAGE = 

             "\n######################\n"

         +   "Latka usage:\n"

         +   "  java org.apache.commons.latka.Latka \"XML_suite_URL\" "

         +   "[\"propfile:file_name\"] [\"prop:prop_name=prop_value\"]\n\n"

         +   "The quotes around properties are REQUIRED.\n"

         +   "######################\n";

     /**

      * Execute a single Latka test suite.  The Latka event listner

      * will receive all the events generated during the test.

      * The Latka packages contain an implmentation of LatkaEventInfo

      * which can generate an XML report according to a standard

      * DTD (see documentation).

      * 

      * @param suite    test suite to execute

      * @param listener target for test events

      * @exception LatkaException

      *                   when any internal error occurs

      * @see XMLReporter XML-based implementation of LatkaEventListener

      */

     public void runTests(Suite suite, LatkaEventListener listener)

                 throws LatkaException {

         try {

             Jelly jelly = new Jelly();

             URL url = suite.getURL();

             jelly.setUrl(url);

             jelly.setValidateXML(_isValidating);

             jelly.setDefaultNamespaceURI("jelly:org.apache.commons.latka.jelly.LatkaTagLibrary");

             JellyContext context = buildJellyContext();

             JellyUtils.getInstance().setLatkaEventListener(context,listener);

             String exturl = url.toExternalForm();

             int lastSlash = exturl.lastIndexOf("/");

             String extBase = exturl.substring(0,lastSlash+1);

             URL baseurl = new URL(extBase);

             context.setCurrentURL(baseurl);

             // add listener

             jelly.compileScript().run(context,XMLOutput.createDummyXMLOutput());

         } catch (Exception e) {

             throw new LatkaException(e);

         }

     }

     protected JellyContext buildJellyContext() {

         JellyContext context = new JellyContext();

         Iterator keys = _props.keySet().iterator();

         while (keys.hasNext()) {

             String key = (String) keys.next();

             String value = _props.getProperty(key);

             context.setVariable(key,value);

         }

         return context;

     }

     /**

      * Set whether or not Latka will validate the XML in

      * each test.

      *

      * @param isValidating whether or not to validate XML

      */

     public void setValidating(boolean isValidating) {

         _isValidating = isValidating;

     }

     /**

      * Set the URL to be used when transforming XML generated by the XMLReporter

      * @param url a valid URL referencing a stylesheet 

      */

     public void setReportStylesheet(URL url) {

         _reportStylesheetUrl = url;

     }

     /**

      * Use this method to log XML generated by the

      * XMLReporter class.

      *

      * @param xml XML to be logged

      * @throws IOException if the XML could not be written to the filesystem

      */

     protected void logXML(String xml) throws IOException {

         String logProp = _props.getProperty("latka.writeLog");

         if ((logProp != null) && (logProp.equals("false"))) {

             return;

         }

         File dir = new File("logs");

         // try to create logs directory. if it fails, then check to

         // make sure it is there (may have existed before) and is writeable

         if (!dir.mkdirs()) {

             if (!dir.exists ()) {

                 throw new IOException("Unable to create logs directory");

             } else if (!dir.canWrite ()) {

                 throw new IOException("Unable to write to logs directory");

             }

         }

         SimpleDateFormat formatter = new SimpleDateFormat ("yyyyMMdd'-'HHmm");

         String dateString = formatter.format(new Date());

         File file = new File(dir, dateString + ".xml");

         FileWriter fileWriter = new FileWriter(file);

         fileWriter.write(xml);

         fileWriter.close();

     }

     /**

      * Transform the XML generated by the XMLReporter using

      * the default stylesheet.

      *

      * @param xml XML generated by XMLReporter

      * @return transformed report

      * @throws LatkaException if the XML could not be transformed

      */

     public String transformXML(String xml) throws LatkaException {

         try {

             StringWriter output = new StringWriter();

             Source xslSource = null;

             if (_reportStylesheetUrl == null) {

             ClassLoader loader = Thread.currentThread().getContextClassLoader();

                    if (loader == null) {

                 // there may not be a context class loader

                 loader = getClass().getClassLoader();

                 }

             xslSource = new StreamSource(

                             loader.getResourceAsStream(

                             "org.apache.commons.latka.report.xsl")

                         );

             } else {

                 xslSource = new StreamSource(_reportStylesheetUrl.toString());

             }

             Transformer transformer = 

             TransformerFactory.newInstance().newTransformer(xslSource);

             StreamSource xmlSource = new StreamSource(new StringReader(xml));

             StreamResult result = new StreamResult(output);

             transformer.transform(xmlSource, result);

             return output.toString();

         } catch (TransformerException e) {

             throw new LatkaException(e);

         }

     }

     /**

      * Processes the command line arguments, executes a single test.

      * and processes the resulting report.  Command line usage is

      * described in the LATKA_USAGE constant.

      *

      * @param args arguments passed into the main(String[]) method

      *

      * @throws LatkaException if any problems are encountered during

      * the execution of the tests

      */

     protected void runCommandLine(String args[]) throws LatkaException {

         if (args.length < 1) {

             System.out.println(LATKA_USAGE);

         }

         String urlString = args[0];

         if (args.length > 1) {

             for (int i = 1; i < args.length; ++i) {

                 String arg = args[i];

                 if (arg.startsWith("prop:")) {

                     String propName = arg.substring(5, arg.indexOf("="));

                     String propValue = arg.substring(arg.indexOf("=") + 1);

                     _props.setProperty(propName, propValue);

                 } else if (arg.startsWith("propfile:")) { 

                     try {

                         _props.load(new FileInputStream(arg.substring(9)));

                     } catch (IOException e) {

                         System.out.println("Could not load user prop file, uri="

                                             + arg.substring(9));

                     }                                            

                 } else {

                     throw new IllegalArgumentException(LATKA_USAGE);

                 }

             } // for

         } // if

         String xml = null;

         XMLReporter listener = new XMLReporter();

         // overkill, all we need is success/failure

         LatkaEventInfo info = new DefaultLatkaEventInfo(listener); 

         try {

             URL url = new URL(urlString);

             Suite suite = new Suite(url);

             runTests(suite, info);

             xml = listener.getDocumentAsString();

             logXML(xml);

         } catch (IOException e) {

             throw new LatkaException(e);

         }

         System.out.println(transformXML(xml));

         if (info.didSuiteSucceed() == false) {

             // throw an exception, so the process will

             // return as a failure

             throw new LatkaException("SUITE FAILED");

         }

     }

     /**

      * Execute a single test suite via the command line

      * interface.  See the Latka documentation for detailed

      * usage instructions.  The Java process will return

      * a 0 if all tests succeed and a 1 if any fail

      * or there is an unrecoverable error in the test

      * execution.

      *

      * @param args arguments containing the test suite location

      *        and any properties or property file references

      */

     public static void main (String args[]) {

         Latka latka = new Latka();

         try {

             latka.runCommandLine(args);

         } catch (LatkaException e) {

             e.printStackTrace();

             System.exit(1);

         }

     }

 }