/*

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

 import java.io.IOException;

 import org.apache.commons.latka.ValidationException;

 import org.apache.commons.latka.http.Response;

 import org.jdom.Document;

 import org.jdom.Element;

 import org.jdom.JDOMException;

 import org.jdom.input.SAXBuilder;

 import org.jaxen.jdom.JDOMXPath;

 import org.jaxen.JaxenException;

 /**

  * An XPath validator.

  *

  * <p>Use is of the form:</p>

  * <p>&lt;xpath select="..." [ value="..." ] [ cond="true | false" ] /&gt;</p>

  * <p>Where :</p>

  * <ul>

  *  <li><code>select</code> is an XPath expression, designed to match a node in

  *  the XML body of the response.</li>

  *  <li><code>value</code> is an option value which the string value of the

  *  selected node should match.</li>

  *  <li><code>cond</code> is an optional boolean value, indicating

  *  whether the test logic is to be inverted. Defaults to

  *  <code>true</code>.</li>

  * </ul>

  *

  * </p>

  * <p>

  * If the user has specified a {@link #setValue value}, then the XPath

  * expression is expected to evaluate to a text or attribute node (or other

  * textual 'leaf' nodes), in which case the selected value must match that

  * specified.

  * </p>

  * <p>

  * If no value is specified, then the XPath expression will be used to check for

  * the <em>existence</em> of a node.

  * </p>

  * <p>

  * If the XPath expression evaluates to a boolean condition (eg

  * <xpath select="foo/bar='baz'"/>), then the condition will be evaluated and will

  * result in the test passing or failing. Equivalently, an expression may be

  * specified, and <code>value</code> used to require a specific value (eg

  * <xpath select="/foo/bar" value="baz"/>).

  * </p>

  * <p>

  * Finally, setting <code>cond="false"</code> negates the sense of the

  * test, allowing one to test for the <em>nonexistence</em> or

  * <em>inequality</em> of nodes and values.

  * </p>

  *

  * @author <a href="mailto:jefft@apache.org">Jeff Turner</a>

  * @author dIon Gillard

  * @since 6 January, 2001

  * @version $Id: XPathValidator.java 155424 2005-02-26 13:09:29Z dirkv $

  */

 public class XPathValidator extends BaseConditionalValidator {

     // General notes:

     // - It started out simple, honest.. =)

     // --------------------------------------------------------------- Attributes

     protected String _select = null;

     protected String _value = null;

     // need the last XPath result for exception generation

     protected Object _lastSelected = null;

     // ------------------------------------------------------------- Constructors

     public XPathValidator() {

         this(null,null,true,null);

     }

     public XPathValidator(String label) {

         this(label,null,true,null);

     }

     public XPathValidator(String label, String select, boolean cond, String value) {

         super(label,cond);

         _select = select;

         _value = value;

     }

     // ------------------------------------------------------------------ Public Methods

     public void setSelect(String select) {

         _select = select;

     }

     public void setValue(String value) {

         _value = value;

     }

     public boolean assertTrue(Response response)

     throws ValidationException {

         JDOMXPath xpath = getJDOMXPath(_select); // compile the XPath expression

         Document doc = getDocument(response); // retrieve the XML Document to process

         Object selected = getSelectedNode(xpath, doc); // Apply the XPath to retrieve a node

         _lastSelected = selected;

         if (selected == null) {

             return false;

         }

         // Now the fun begins, where we see if our selected node meets the criteria.

         // There are two factors:

         // 

         // 1) What type of object did the XPath expression return?

         // 2) If _value is specified, ie if we're testing for _value_ or _existence_

         if (selected instanceof Boolean) {

             // Eg, we had an expression /foo = 'bar'

             _log.debug("Boolean XPath expression evaluated to "+selected);

             if (_value != null) {

                 _log.warn("Ignoring unused value '"+_value+"'.");

             }

             boolean matched = ((Boolean)selected).booleanValue();

             return matched;

         } else if (selected instanceof String) {

             _log.debug("XPath selected string '"+selected+"'.");

             if (_value != null) {

                 boolean matched = selected.equals(_value);

                 return matched;

             } else {

                 // otherwise we only test if the node is meant to exist

                 return true;

             }

         } else if (selected instanceof Element) {

             if (_log.isDebugEnabled()) {

                 _log.debug("XPath matched element: ");

                 _log.debug(printElement((Element)selected));

             }

             if (_value != null) {

                 _log.warn("Ignoring unused value '"+_value+"'.");

             }

             // otherwise we only test if the node is meant to exist

             return true;

         } else {

             // Otherwise Jaxen is returning something odd

             if (_value != null) {

                 // Hope that .equals() does a sensible comparison

                 boolean matched = selected.equals(_value);

                 return matched;

             } else {

                 _log.warn("Selected unknown type "+selected.getClass().getName());

                 // only test if the node (whatever it is) is meant to exist

                 return true;

             }

         }

     }

     public String generateBareExceptionMessage() {

         if (_lastSelected == null) {

             return " THAT BOOLEAN XPATH '"+_select+"' WOULD SELECT SOME NODE.";

         }

         if (_lastSelected instanceof Boolean) {

             return " THAT BOOLEAN XPATH '"+_select+"' WOULD RETURN '" + getCondition() + "'.";

         } else if (_lastSelected instanceof String) {

             if (_value != null) {

                 StringBuffer buf = new StringBuffer();

                 buf.append(" THAT XPATH '");

                 buf.append(_select);

                 buf.append("' WOULD SELECT '");

                 buf.append(_value);

                 buf.append("', RECEIVED '");

                 buf.append(_lastSelected);

                 buf.append("'.");

                 return buf.toString();

             } else {

                 // otherwise we only test if the node is meant to exist

                 return " THAT XPATH '" + _select + "' WOULD SELECT SOMETHING.";

             }

         } else if (_lastSelected instanceof Element) {

                 // otherwise we only test if the node is meant to exist

                 return " THAT XPATH '" + _select + "' WOULD SELECT SOMETHING.";

         } else {

             // Otherwise Jaxen is returning something odd

             if (_value != null) {

                 return " THAT XPATH EXPRESSION '"+_select+"' WOULD RETURN '" + _value +

                        "', RETURNED UNKNOWN TYPE "+_lastSelected.getClass().getName()+ ".";

             } else {

                 _log.warn("Selected unknown type "+_lastSelected.getClass().getName());

                 // only test if the node (whatever it is) is meant to exist

                 return " THAT XPATH '" + _select + "' WOULD SELECT SOMETHING.";

             }

         }

     }

     // ------------------------------------------------------------------ Private Methods

     /**

      * Creates a Jaxen <code>JDOMXPath</code> for a given XPath expression.

      * @param xpathExpr The XPath expression

      * @return A non-null Jaxen <code>JDOMXPath</code> object.

      * @throws ValidationException if <code>xpathExpr</code> was invalid.

      */

     private JDOMXPath getJDOMXPath(final String xpathExpr)

     throws ValidationException

     {

         JDOMXPath xpath = null;

         try {

             xpath = new JDOMXPath(xpathExpr);

         } catch (JaxenException e) {

             fail("Couldn't compile JDOMXPath xpathExpr "+xpathExpr+": "+e.toString());

         }

         if (xpath == null) { // this should never happen

             fail("Null compiled XPath object");

         }

         if (_log.isDebugEnabled()) {

             _log.debug("Using XPath expression: "+xpathExpr);

         }

         return xpath;

     }

     /**

      * Creates a <code>Document</code> from the Response.

      * @param response The (usu. HTTP) Reponse object presumably containing an XML

      * response body.

      * @return A non-null <code>Document</code> representing the response body.

      * @throws ValidationException if the Response object's body did not contain

      * well-formed XML.

      */

     private Document getDocument(Response response)

     throws ValidationException

     {

         Document doc = null;

         SAXBuilder builder = new SAXBuilder();

         try {

             doc = builder.build(response.getStream());

         } catch (Exception e) {

             if (e instanceof IOException || e instanceof JDOMException) {

                 fail(e.toString());

             } else {

                 fail("Unknown exception caught: " + e.toString());

             }

         }

         if (doc == null) { // this should never happen

             fail("Null document");

         }

         if (_log.isDebugEnabled()) {

             _log.debug("Processing doc: "+printDoc(doc));

         }

         return doc;

     }

     /**

      * Apply a compiled XPath expression to an XML Document, and return the

      * selected node. 

      * @param xpath The compiled Jaxen <code>XPath</code> object

      * @param doc The <code>Document</code> object containing the XML.

      * @return An object returned from Jaxen, or null if there was no match. This may be:

      * <ul>

      *  <li>A String, if the expression selected an element with a text node child</li>

      *  <li>An <code>Element</code></li>

      *  <li>A <code>java.lang.Boolean</code>, if the XPath expression is a

      *  statement (eg /foo/bar='content')</li>

      *  <li>Anything else the Jaxen author deemed useful; ie don't assume anything</li>

      * </ul>

      */

     private Object getSelectedNode(JDOMXPath xpath, Document doc)

     throws ValidationException

     {

         Object selected = null;

         try {

             selected = xpath.selectSingleNode(doc);

         } catch (JaxenException e) {

             fail("XPath expression '"+_select+"' didn't match any node. "+e.toString());

         }

         return selected;

     }

     /**

      * Utility method for returning an XML rendition of a <code>Document</code>.

      * @param doc The Document to print

      * @return A String of XML representing the document.

      */

     private String printDoc(final Document doc) {

         java.io.StringWriter sw = new java.io.StringWriter();

         try {

             new org.jdom.output.XMLOutputter().output(doc, sw);

         } catch (java.io.IOException ioe) {

             _log.error("Could not print XML document.", ioe);

         }

         return sw.toString();

     }

     /**

      * Utility method for returning an XML rendition of a <code>Element</code>.

      * @param elem an <code>Element</code> to print.

      * @return A String of XML representing the element.

      */

     private String printElement(final Element elem) {

         java.io.StringWriter sw = new java.io.StringWriter();

         Element clone = (Element)((Element)elem).clone();

         org.jdom.output.XMLOutputter xmlOut = new org.jdom.output.XMLOutputter();

         try {

             xmlOut.output(new org.jdom.Document(clone), sw);

         } catch (java.io.IOException ioe) {

             _log.error("Could not print XML element.", ioe);

         }

         return sw.toString();

     }

 }