X-Git-Url: http://wamblee.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=support%2Fgeneral%2Fsrc%2Ftest%2Fjava%2Forg%2Fwamblee%2Fxml%2FXslTransformerTest.java;fp=support%2Fgeneral%2Fsrc%2Ftest%2Fjava%2Forg%2Fwamblee%2Fxml%2FXslTransformerTest.java;h=d30e60a6327b10b0911efe694244e9874e718c8e;hb=32a62ca2c752e33a7873ac868a7a1f289caedcd4;hp=0000000000000000000000000000000000000000;hpb=d2bdf4e813c6a3964958c87b2ce56eaadf8a1f0a;p=utils diff --git a/support/general/src/test/java/org/wamblee/xml/XslTransformerTest.java b/support/general/src/test/java/org/wamblee/xml/XslTransformerTest.java new file mode 100644 index 00000000..d30e60a6 --- /dev/null +++ b/support/general/src/test/java/org/wamblee/xml/XslTransformerTest.java @@ -0,0 +1,257 @@ +/* + * 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 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; + +import junit.framework.TestCase; +import org.wamblee.io.ClassPathResource; +import org.wamblee.io.FileSystemUtils; +import org.wamblee.io.InputResource; + +import org.w3c.dom.Document; + +/** + * 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); + } + +} + +