non-releases/trunk_before_flattening/src/test/org/apache/cocoon/test/ServletTestCase.java

/*
 * Copyright 1999-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.cocoon.test;

import java.io.File;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Vector;


import junit.framework.TestCase;

import org.apache.avalon.framework.logger.ConsoleLogger;
import org.apache.avalon.framework.logger.Logger;
import org.apache.cocoon.Cocoon;

import com.meterware.httpunit.GetMethodWebRequest;
import com.meterware.httpunit.WebRequest;
import com.meterware.httpunit.WebResponse;
import com.meterware.servletunit.ServletRunner;
import com.meterware.servletunit.ServletUnitClient;

public class ServletTestCase extends TestCase {

	private ServletRunner servletRunner;
    protected ServletUnitClient client;

    private Logger logger;
    private URL classDirURL;
    
    protected String processorClassName = Cocoon.class.getName();

    protected void setUp() throws Exception {
        super.setUp();
        
        String level = System.getProperty("junit.test.loglevel", "" + ConsoleLogger.LEVEL_DEBUG);
        this.logger = new ConsoleLogger(Integer.parseInt(level));

        this.classDirURL = this.getClassDirURL();
        URL webInf = new URL(classDirURL, "WEB-INF/web.xml");
        File webInfFile = new File(webInf.getPath());
        this.servletRunner = new ServletRunner(webInfFile, "");
        this.client = this.servletRunner.newClient();
    }

    protected void tearDown() throws Exception {
    	this.servletRunner.shutDown();
        super.tearDown();
    }

    /** Return the logger */
    protected Logger getLogger() {
        return this.logger;
    }
    
    /**
     * Utility method for geting the URL to the directory that this class is in
     */
    protected URL getClassDirURL() throws RuntimeException {
        String className = getClass().getName().replace( '.', '/' ) + ".class";
        String classURL = null;
        String classDir = null;
        try {
            classURL =
                getClass().getClassLoader().getResource(className).toExternalForm();
            getLogger().debug("classURL=" + classURL);
            classDir = classURL.substring(0, classURL.lastIndexOf('/') + 1);
            getLogger().debug("classDir=" + classDir);
            return new URL(classDir);
        } catch (SecurityException e) {
            throw new RuntimeException("Not allowed to access classloader for " + className, e);
        } catch (MalformedURLException e) {
            throw new RuntimeException("Malformed URL for className=" + className +
                                       " classURL=" + classURL + " classDir=" + classDir, e);
        } catch (Exception e) {
            throw new RuntimeException("Couldn't create URL for " + className, e);
        }
    }

    /**
     * Load a binary document.
     *
     * @param input Stream containing the document.
     *
     * @return Binary data.
     */
    public final byte[] loadByteArray(InputStream input) {

        byte[] assertiondocument = null;

        try {
            Vector document = new Vector();
            int i = 0;
            int c;

            while ((c = input.read())!=-1) {
                document.add(new Byte((byte) c)); 
                i++;
            }
            assertiondocument = new byte[document.size()];
            for (i = 0; i < document.size(); i++) {
                assertiondocument[i] = ((Byte)document.get(i)).byteValue();
            }

        } catch (Exception e) {
            getLogger().error("Could not execute test", e);
            fail("Could not execute test: "+e);
        }

        return assertiondocument;
    }

    /**
     * Assert that the result of a byte comparison is identical.
     *
     * @param expected The expected byte array
     * @param actual The actual byte array
     */
    public final void assertIdentical(byte[] expected, byte[] actual) {
        assertEquals("Byte arrays of differing sizes, ", expected.length,
                     actual.length);

        if (expected.length>0) {
            for (int i = 0; i<expected.length; i++) {
                assertEquals("Byte array differs at index "+i, expected[i],
                             actual[i]);
            }
        }

    }

    protected InputStream process(String uri) throws Exception {
    	String dummySite = "http://www.test.org";
    	WebRequest request = new GetMethodWebRequest(dummySite + uri);
    	/*
    	InvocationContext ic = this.client.newInvocation(request);
    	ic.getServlet();
    	ic.service();
    	WebResponse response = ic.getServletResponse();
    	*/
    	WebResponse response = this.client.getResponse(request);
    	getLogger().info("Content type: " + response.getContentType());
    	getLogger().info("Content length: " + response.getContentLength());
    	getLogger().info("Output: " + response.getText());

        return response.getInputStream();
    }

    protected void pipeTest(String uri, String expectedSource) throws Exception {
        byte[] expected = loadByteArray((new URL(classDirURL, expectedSource)).openStream());
        byte[] actual = loadByteArray(process(uri));
        assertIdentical(expected, actual);
    }
}