/*
 * Copyright 2005 the original author or authors.
 *
 * 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.wamblee.xml;

import junit.framework.TestCase;

import org.w3c.dom.Document;

import org.wamblee.io.ClassPathResource;
import org.wamblee.io.FileSystemUtils;
import org.wamblee.io.InputResource;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.TransformerException;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

/**
 * Tests the XSL transformer.
 * 
 * @author Erik Brakkee
 */
public class XslTransformerTest extends TestCase {
    private static final String INCLUDED_XSL_FILE = "utilities.xsl";
    private static final String REPORT_XML = "report.xml";
    private static final String REPORT_TO_HTML_XSLT = "reportToHtml.xsl";
    private static final String REPORT_TO_HTML2_XSLT = "reportToHtml2.xsl";
    private static final String REPORT_TO_HTML_INVALID_XSLT = "reportToHtml-invalid.xsl";
    private static final String REPORT_TO_HTML_NONWELLFORMED_XSLT = "reportToHtml-nonwellformed.xsl";
    private static final String REPORT_TO_TEXT_XSLT = "reportToText.xsl";

    private String getResourcePath(String aResource) {
        return getClass().getPackage().getName().replaceAll("\\.", "/") + "/" +
            aResource;
    }

    /**
     * Transforms a file while using the default resolver, where the included
     * file can be found. Verifies the transformation is done correctly.
     * 
     */
    public void testTransformUsingDefaultResolver() throws Exception {
        XslTransformer transformer = new XslTransformer();

        InputResource xmlResource = new ClassPathResource(
            getResourcePath(REPORT_XML));

        Source xslt = new StreamSource(new ClassPathResource(
            getResourcePath(REPORT_TO_HTML_XSLT)).getInputStream());

        byte[] documentData = FileSystemUtils
            .read(xmlResource.getInputStream()).getBytes();
        DocumentBuilder builder = DocumentBuilderFactory.newInstance()
            .newDocumentBuilder();
        Document document = builder.parse(xmlResource.getInputStream());
        Source documentSource = new StreamSource(xmlResource.getInputStream());

        Document expected = DomUtils
            .read(new ClassPathResource(
                getResourcePath("output-reportToHtml-report.xml"))
                .getInputStream());

        Document output1 = transformer.transform(documentData, xslt);
        XmlUtils.assertEquals("byte[] transform", expected, output1);

        xslt = new StreamSource(new ClassPathResource(
            getResourcePath(REPORT_TO_HTML_XSLT)).getInputStream());

        Document output2 = transformer.transform(document, xslt);
        XmlUtils.assertEquals("document transform", expected, output2);

        ByteArrayOutputStream os = new ByteArrayOutputStream();
        Result output = new StreamResult(os);

        xslt = new StreamSource(new ClassPathResource(
            getResourcePath(REPORT_TO_HTML_XSLT)).getInputStream());
        transformer.transform(documentSource, output, xslt);
        XmlUtils.assertEquals("document source transform", expected, DomUtils
            .read(os.toString()));

        xslt = new StreamSource(new ClassPathResource(
            getResourcePath(REPORT_TO_HTML_XSLT)).getInputStream());

        String result = transformer.textTransform(documentData, xslt);
        XmlUtils
            .assertEquals("text transform", expected, DomUtils.read(result));
    }

    /**
     * Transforms a file using the default resolver where the included file
     * cannot be found. Verifies that a TransformerException is thrown.
     * 
     */
    public void testTransformUsingDefaultResolverFails() throws IOException {
        XslTransformer transformer = new XslTransformer();

        InputResource xmlResource = new ClassPathResource(
            getResourcePath(REPORT_XML));
        Source xslt = new StreamSource(new ClassPathResource(
            getResourcePath(REPORT_TO_HTML2_XSLT)).getInputStream());

        byte[] documentData = FileSystemUtils
            .read(xmlResource.getInputStream()).getBytes();

        try {
            Document output1 = transformer.transform(documentData, xslt);
        } catch (TransformerException e) {
            return; // ok
        }

        fail();
    }

    /**
     * Transforms a file using an invalid Xslt. Verifies that a
     * TransformerException is thrown.
     * 
     */
    public void testTransformInvalidXslt() throws IOException {
        XslTransformer transformer = new XslTransformer();

        InputResource xmlResource = new ClassPathResource(
            getResourcePath(REPORT_XML));
        Source xslt = new StreamSource(new ClassPathResource(
            getResourcePath(REPORT_TO_HTML_INVALID_XSLT)).getInputStream());

        byte[] documentData = FileSystemUtils
            .read(xmlResource.getInputStream()).getBytes();

        try {
            Document output1 = transformer.transform(documentData, xslt);
        } catch (TransformerException e) {
            return; // ok
        }

        fail();
    }

    /**
     * Transforms a file using a non-well formed xslt. Verifies that a
     * TransformerException is thrown.
     * 
     */
    public void testTransformNonWellformedXslt() throws IOException {
        XslTransformer transformer = new XslTransformer();

        InputResource xmlResource = new ClassPathResource(
            getResourcePath(REPORT_XML));
        Source xslt = new StreamSource(new ClassPathResource(
            getResourcePath(REPORT_TO_HTML_NONWELLFORMED_XSLT))
            .getInputStream());

        byte[] documentData = FileSystemUtils
            .read(xmlResource.getInputStream()).getBytes();

        try {
            Document output1 = transformer.transform(documentData, xslt);
        } catch (TransformerException e) {
            return; // ok
        }

        fail();
    }

    /**
     * Transforms a file using a class path resolver.
     * 
     */
    public void testTransformUsingClassPathResolver() throws Exception {
        XslTransformer transformer = new XslTransformer(
            new ClasspathUriResolver());

        InputResource xmlResource = new ClassPathResource(
            getResourcePath(REPORT_XML));
        Source xslt = new StreamSource(new ClassPathResource(
            getResourcePath(REPORT_TO_HTML2_XSLT)).getInputStream());

        byte[] documentData = FileSystemUtils
            .read(xmlResource.getInputStream()).getBytes();

        Document output1 = transformer.transform(documentData, xslt);
        Document expected = DomUtils
            .read(new ClassPathResource(
                getResourcePath("output-reportToHtml-report.xml"))
                .getInputStream());
        XmlUtils.assertEquals("doc", expected, output1);
    }

    /**
     * Transforms a file to text output. Verifies the file is transformed
     * correctly.
     * 
     */
    public void testTransformToTextOutput() throws Exception {
        XslTransformer transformer = new XslTransformer(
            new ClasspathUriResolver());

        InputResource xmlResource = new ClassPathResource(
            getResourcePath(REPORT_XML));
        Source xslt = new StreamSource(new ClassPathResource(
            getResourcePath(REPORT_TO_TEXT_XSLT)).getInputStream());

        byte[] documentData = FileSystemUtils
            .read(xmlResource.getInputStream()).getBytes();

        String result = transformer.textTransform(documentData, xslt);
        String expected = "Hello world!";
        assertEquals("text transform", expected, result);
    }

    /**
     * Tests resolving a file using {@link XslTransformer#resolve(String)} with
     * the default resolver where the file does not exist.
     * 
     */
    public void testResolveWithDefaultResolverFileNotFound() {
        XslTransformer transformer = new XslTransformer();

        try {
            Source source = transformer
                .resolve("org/wamblee/xml/utilities-nonexistent.xsl");
        } catch (TransformerException e) {
            return; // ok
        }

        fail();
    }

    /**
     * Tests resolving a file using {@link XslTransformer#resolve(String)} with
     * the default resolver.
     * 
     */
    public void testResolveWithClasspathResolver() throws Exception {
        XslTransformer transformer = new XslTransformer(
            new ClasspathUriResolver());
        Source source = transformer.resolve(getResourcePath(INCLUDED_XSL_FILE));
        assert (source instanceof StreamSource);

        StreamSource ssource = (StreamSource) source;
        String data = FileSystemUtils.read(ssource.getInputStream());
        String expected = FileSystemUtils.read(new ClassPathResource(
            getResourcePath(INCLUDED_XSL_FILE)).getInputStream());
        assertEquals(expected, data);
    }
}