/*** 
    * 
    * Copyright 2004 Protique Ltd
    * 
    * 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.codehaus.activesoap;
  
  import junit.framework.TestCase;
  import org.apache.xmlbeans.XmlObject;
  import org.apache.xmlbeans.XmlOptions;
  
  import javax.xml.stream.XMLInputFactory;
  import javax.xml.stream.XMLOutputFactory;
  import javax.xml.stream.XMLStreamException;
  import javax.xml.stream.XMLStreamReader;
  import javax.xml.stream.XMLStreamWriter;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.Reader;
  import java.io.StringReader;
  import java.io.StringWriter;
  import java.io.Writer;
  import java.net.URL;
  
  /***
   * @version $Revision: 1.3 $
   */
  public abstract class TestSupport extends TestCase {
      protected SoapService service;
      private XmlOptions options = new XmlOptions();
      protected XMLInputFactory inputFactory;
      protected boolean repairing = false;
  
      protected void assertResponse(String requestMessage, String intermediary, String responseMessage) throws Exception {
  
          // lets use an intermediary
          SoapService previousSesrvice = service;
          service = new SoapService();
          service.setIntermediary(true);
          service.getRoles().add("http://example.org/ts-tests/B");
  
          String intermediateText = assertResponse(requestMessage, intermediary);
          Reader in = new StringReader(intermediateText);
  
          // restore the endpoint context
          service = previousSesrvice;
          if (responseMessage != null) {
              assertResponse(in, responseMessage);
          }
      }
  
      protected String assertResponse(String requestMessage, String responseMessage) throws Exception {
          return assertResponse(createReader(requestMessage), responseMessage);
      }
  
      protected String assertResponse(Reader in, String responseMessage) throws Exception {
          StringWriter out = new StringWriter();
          service.invoke(in, out);
  
          String responseText = out.toString();
  
          XmlObject expected = XmlObject.Factory.parse(getClass().getResource(responseMessage), options);
          XmlObject actual = prettyPrintXml(responseText);
  
          System.out.println();
          System.out.println("Pretty printed response:-");
          System.out.println(actual);
          System.out.println();
          assertXml(expected, actual);
          return responseText;
      }
  
      protected XMLStreamWriter createStreamWriter(Writer writer) throws XMLStreamException {
          XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
          if (repairing) {
              outputFactory.setProperty("javax.xml.stream.isRepairingNamespaces", Boolean.TRUE);
          }
          XMLStreamWriter out = outputFactory.createXMLStreamWriter(writer);
          return out;
      }
  
      private void assertXml(XmlObject expected, XmlObject actual) {
          int value = expected.compareValue(actual);
          System.out.println("Value: " + value);
  
          assertEquals("Response does not match expected results", expected.toString(), actual.toString());
     }
 
     protected void setUp() throws Exception {
         super.setUp();
         options.setLoadStripWhitespace();
         options.setLoadStripComments();
         options.setLoadTrimTextBuffer();
         options.setSavePrettyPrint();
         service = new SoapService();
     }
 
     protected XMLStreamReader createXMLStreamReader(URL resource) throws XMLStreamException, IOException {
         assertTrue("Found resource", resource != null);
 
         XMLInputFactory inputFactory = getInputFactory();
         XMLStreamReader in = inputFactory.createXMLStreamReader(resource.openStream());
         return in;
     }
 
     protected XMLInputFactory getInputFactory() {
         if (inputFactory == null) {
             inputFactory = XMLInputFactory.newInstance();
             inputFactory.setProperty("javax.xml.stream.supportDTD", Boolean.FALSE);
         }
         return inputFactory;
     }
 
     protected XMLStreamReader createXMLStreamReader(String name) throws XMLStreamException, IOException {
         return createXMLStreamReader(getClass().getResource(name));
     }
 
     /***
      * Creates a reader for a resource on the classpath in this classes packaget
      */
     protected Reader createReader(String uri) {
         InputStream in = getClass().getResourceAsStream(uri);
         assertTrue("No resource found on the classpath in the package of class: " + getClass().getName()
                 + " for uri: " + uri, in != null);
         return new InputStreamReader(in);
     }
 
     protected XMLStreamWriter createXMLStreamWriter(Writer writer) throws XMLStreamException {
         return XMLOutputFactory.newInstance().createXMLStreamWriter(writer);
     }
 
     protected XmlObject prettyPrintXml(String xml) throws Exception {
         if (xml.trim().length() == 0) {
             fail("Empty string cannot be parsed!");
         }
         try {
             return XmlObject.Factory.parse(new StringReader(xml), options);
         }
         catch (Exception e) {
             System.out.println("Failed to parse XML due to: " + e);
             System.out.println("Raw XML:");
             System.out.println();
             System.out.println(xml);
             System.out.println();
             e.printStackTrace();
             throw e;
         }
     }
 }