| package org.apache.taverna.scufl2.ucfpackage; |
| /* |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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. |
| * |
| */ |
| |
| |
| import static org.junit.Assert.assertArrayEquals; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertNotSame; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.zip.ZipEntry; |
| import java.util.zip.ZipFile; |
| |
| import org.apache.commons.io.FileUtils; |
| import org.apache.commons.io.IOUtils; |
| import org.apache.commons.io.output.ByteArrayOutputStream; |
| import org.apache.taverna.scufl2.ucfpackage.UCFPackage.ResourceEntry; |
| import org.jdom2.Attribute; |
| import org.jdom2.Document; |
| import org.jdom2.Element; |
| import org.jdom2.JDOMException; |
| import org.jdom2.Namespace; |
| import org.jdom2.input.SAXBuilder; |
| import org.jdom2.xpath.XPath; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| @SuppressWarnings("resource") |
| public class TestUCFPackage { |
| |
| private static final int MIME_OFFSET = 30; |
| private static final boolean DELETE_FILES = false; |
| private static final Namespace MANIFEST_NS = Namespace.getNamespace("manifest", |
| "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"); |
| private static final Namespace EXAMPLE_NS = Namespace.getNamespace("ex", "http://example.com/"); |
| private static final Namespace CONTAINER_NS = Namespace.getNamespace("c", "urn:oasis:names:tc:opendocument:xmlns:container"); |
| private File tmpFile; |
| |
| |
| protected Document parseXml(InputStream stream) |
| throws JDOMException, IOException { |
| SAXBuilder saxBuilder = new SAXBuilder(); |
| return saxBuilder.build(stream); |
| } |
| |
| protected void assertXpathEquals(String expected, Element element, |
| String xpath) throws JDOMException { |
| Object o = xpathSelectElement(element, xpath); |
| if (o == null) { |
| fail("Can't find " + xpath + " in " + element); |
| return; |
| } |
| String text; |
| if (o instanceof Attribute) { |
| text = ((Attribute)o).getValue(); |
| } else { |
| text = ((Element)o).getValue(); |
| } |
| assertEquals(expected, text); |
| } |
| |
| |
| protected Object xpathSelectElement(Element element, String xpath) throws JDOMException { |
| XPath x = XPath.newInstance(xpath); |
| x.addNamespace(MANIFEST_NS); |
| x.addNamespace(CONTAINER_NS); |
| x.addNamespace(EXAMPLE_NS); |
| return x.selectSingleNode(element); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void mimeTypeInvalidCharset() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| // Not even Latin-1 chars allowed |
| container.setPackageMediaType("food/brød"); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void mimeTypeEmpty() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(""); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void mimeTypeNoSlash() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType("nonvalid"); |
| } |
| |
| @Test(expected = IllegalStateException.class) |
| public void noDefaultMimeType() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.save(tmpFile); |
| } |
| |
| @Test |
| public void mimeTypePosition() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_EPUB); |
| assertEquals(UCFPackage.MIME_EPUB, container.getPackageMediaType()); |
| container.save(tmpFile); |
| assertTrue(tmpFile.exists()); |
| ZipFile zipFile = new ZipFile(tmpFile); |
| // Must be first entry |
| ZipEntry mimeEntry = zipFile.entries().nextElement(); |
| assertEquals("First zip entry is not 'mimetype'", "mimetype", |
| mimeEntry.getName()); |
| assertEquals( |
| "mimetype should be uncompressed, but compressed size mismatch", |
| mimeEntry.getCompressedSize(), mimeEntry.getSize()); |
| assertEquals("mimetype should have STORED method", ZipEntry.STORED, |
| mimeEntry.getMethod()); |
| assertEquals("Wrong mimetype", UCFPackage.MIME_EPUB, |
| IOUtils.toString(zipFile.getInputStream(mimeEntry), "ASCII")); |
| |
| // Check position 30++ according to |
| // http://livedocs.adobe.com/navigator/9/Navigator_SDK9_HTMLHelp/wwhelp/wwhimpl/common/html/wwhelp.htm?context=Navigator_SDK9_HTMLHelp&file=Appx_Packaging.6.1.html#1522568 |
| byte[] expected = ("mimetype" + UCFPackage.MIME_EPUB + "PK") |
| .getBytes("ASCII"); |
| FileInputStream in = new FileInputStream(tmpFile); |
| byte[] actual = new byte[expected.length]; |
| try { |
| assertEquals(MIME_OFFSET, in.skip(MIME_OFFSET)); |
| assertEquals(expected.length, in.read(actual)); |
| } finally { |
| in.close(); |
| } |
| assertArrayEquals(expected, actual); |
| } |
| |
| @Before |
| public void createTempFile() throws IOException { |
| tmpFile = File.createTempFile("scufl2-test", ".bundle"); |
| assertTrue(tmpFile.delete()); |
| if (DELETE_FILES) { |
| tmpFile.deleteOnExit(); |
| } else { |
| System.out.println(tmpFile); |
| } |
| } |
| |
| @Test |
| public void workflowBundleMimeType() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| assertEquals(UCFPackage.MIME_WORKFLOW_BUNDLE, |
| container.getPackageMediaType()); |
| container.save(tmpFile); |
| ZipFile zipFile = new ZipFile(tmpFile); |
| ZipEntry mimeEntry = zipFile.getEntry("mimetype"); |
| assertEquals("mimetype", mimeEntry.getName()); |
| assertEquals("Wrong mimetype", UCFPackage.MIME_WORKFLOW_BUNDLE, |
| IOUtils.toString(zipFile.getInputStream(mimeEntry), "ASCII")); |
| |
| } |
| |
| @Test |
| public void fileEntryFromString() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| |
| container |
| .addResource("Hello there þĸł", "helloworld.txt", "text/plain"); |
| |
| container.save(tmpFile); |
| ZipFile zipFile = new ZipFile(tmpFile); |
| ZipEntry manifestEntry = zipFile.getEntry("META-INF/manifest.xml"); |
| InputStream manifestStream = zipFile.getInputStream(manifestEntry); |
| //System.out.println(IOUtils.toString(manifestStream, "UTF-8")); |
| /* |
| <?xml version="1.0" encoding="UTF-8"?> |
| <manifest:manifest xmlns:manifest="urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"> |
| <manifest:file-entry manifest:media-type="text/plain" manifest:full-path="helloworld.txt" manifest:size="18"/> |
| </manifest:manifest> |
| */ |
| Document doc = parseXml(manifestStream); |
| assertEquals(MANIFEST_NS, doc.getRootElement().getNamespace()); |
| assertEquals("manifest", doc.getRootElement().getNamespacePrefix()); |
| assertEquals("manifest:manifest", doc.getRootElement().getQualifiedName()); |
| assertXpathEquals("text/plain", doc.getRootElement(), "/manifest:manifest/manifest:file-entry/@manifest:media-type"); |
| assertXpathEquals("helloworld.txt", doc.getRootElement(), "/manifest:manifest/manifest:file-entry/@manifest:full-path"); |
| /* |
| * Different platforms encode UTF8 in different ways |
| * assertXpathEquals("18", doc.getRootElement(), "/manifest:manifest/manifest:file-entry/@manifest:size"); |
| */ |
| |
| InputStream io = zipFile.getInputStream(zipFile |
| .getEntry("helloworld.txt")); |
| assertEquals("Hello there þĸł", IOUtils.toString(io, "UTF-8")); |
| } |
| |
| @Test |
| public void retrieveStringLoadedFromFile() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container |
| .addResource("Hello there þĸł", "helloworld.txt", "text/plain"); |
| container.save(tmpFile); |
| |
| UCFPackage loaded = new UCFPackage(tmpFile); |
| String s = loaded.getResourceAsString("helloworld.txt"); |
| assertEquals("Hello there þĸł", s); |
| } |
| |
| @Test |
| public void doubleSave() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container |
| .addResource("Hello there þĸł", "helloworld.txt", "text/plain"); |
| container.save(tmpFile); |
| container.addResource("Hello again", "again.txt", "text/plain"); |
| container.save(tmpFile); |
| ZipFile zipFile = new ZipFile(tmpFile); |
| assertNotNull(zipFile.getEntry("helloworld.txt")); |
| |
| assertNotNull(zipFile.getEntry("again.txt")); |
| } |
| |
| @Test |
| public void doubleSaveOutputStream() throws Exception { |
| ByteArrayOutputStream outStream = new ByteArrayOutputStream(); |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container |
| .addResource("Hello there þĸł", "helloworld.txt", "text/plain"); |
| container.save(outStream); |
| container.addResource("Hello again", "again.txt", "text/plain"); |
| outStream.close(); |
| |
| outStream = new ByteArrayOutputStream(); |
| container.save(outStream); |
| outStream.close(); |
| |
| FileUtils.writeByteArrayToFile(tmpFile, outStream.toByteArray()); |
| ZipFile zipFile = new ZipFile(tmpFile); |
| assertNotNull(zipFile.getEntry("helloworld.txt")); |
| assertNotNull(zipFile.getEntry("again.txt")); |
| } |
| |
| @Test |
| public void retrieveBytesLoadedFromFile() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| byte[] bytes = makeBytes(2048); |
| container.addResource(bytes, "randomBytes", "application/octet-stream"); |
| container.save(tmpFile); |
| |
| UCFPackage loaded = new UCFPackage(tmpFile); |
| byte[] loadedBytes = loaded.getResourceAsBytes("randomBytes"); |
| assertArrayEquals(bytes, loadedBytes); |
| } |
| |
| @Test |
| public void addResourceOutputStream() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| byte[] bytes = makeBytes(2048); |
| |
| OutputStream outStream = container.addResourceUsingOutputStream("randomBytes", "application/octet-stream"); |
| IOUtils.write(bytes, outStream); |
| |
| assertTrue(container.listResources().isEmpty()); |
| |
| outStream.close(); |
| assertFalse(container.listResources().isEmpty()); |
| |
| container.save(tmpFile); |
| UCFPackage loaded = new UCFPackage(tmpFile); |
| byte[] loadedBytes = loaded.getResourceAsBytes("randomBytes"); |
| assertArrayEquals(bytes, loadedBytes); |
| } |
| |
| @Test |
| public void retrieveInputStreamLoadedFromFile() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| byte[] bytes = makeBytes(4929); |
| container.addResource(bytes, "randomBytes", "application/octet-stream"); |
| container.save(tmpFile); |
| |
| UCFPackage loaded = new UCFPackage(tmpFile); |
| InputStream entryAsInputStream = loaded |
| .getResourceAsInputStream("randomBytes"); |
| byte[] loadedBytes = IOUtils.toByteArray(entryAsInputStream); |
| assertArrayEquals(bytes, loadedBytes); |
| } |
| |
| @Test |
| public void fileEntryFromBytes() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| |
| byte[] bytes = makeBytes(1024); |
| container.addResource(bytes, "binary", UCFPackage.MIME_BINARY); |
| |
| container.save(tmpFile); |
| ZipFile zipFile = new ZipFile(tmpFile); |
| ZipEntry manifestEntry = zipFile.getEntry("META-INF/manifest.xml"); |
| InputStream manifestStream = zipFile.getInputStream(manifestEntry); |
| |
| //System.out.println(IOUtils.toString(manifestStream, "UTF-8")); |
| /* |
| <?xml version="1.0" encoding="UTF-8"?> |
| <manifest:manifest xmlns:manifest="urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"> |
| <manifest:file-entry manifest:media-type="application/octet-stream" manifest:full-path="binary" manifest:size="1024"/> |
| </manifest:manifest> |
| */ |
| Document doc = parseXml(manifestStream); |
| assertEquals(MANIFEST_NS, doc.getRootElement().getNamespace()); |
| assertEquals("manifest", doc.getRootElement().getNamespacePrefix()); |
| assertEquals("manifest:manifest", doc.getRootElement().getQualifiedName()); |
| assertXpathEquals("application/octet-stream", doc.getRootElement(), "/manifest:manifest/manifest:file-entry/@manifest:media-type"); |
| assertXpathEquals("binary", doc.getRootElement(), "/manifest:manifest/manifest:file-entry/@manifest:full-path"); |
| assertXpathEquals("1024", doc.getRootElement(), "/manifest:manifest/manifest:file-entry/@manifest:size"); |
| |
| InputStream io = zipFile.getInputStream(zipFile.getEntry("binary")); |
| assertArrayEquals(bytes, IOUtils.toByteArray(io)); |
| } |
| |
| protected static byte[] makeBytes(int size) { |
| byte[] bytes = new byte[size]; |
| for (int i = 0; i < size; i++) { |
| bytes[i] = (byte) i; |
| } |
| return bytes; |
| } |
| |
| @Test |
| public void fileListing() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| Set<String> expectedFiles = new HashSet<String>(); |
| Set<String> expectedSubFiles = new HashSet<String>(); |
| Set<String> expectedSubSubFiles = new HashSet<String>(); |
| |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| expectedFiles.add("helloworld.txt"); |
| |
| container.addResource("Soup for everyone", "soup.txt", "text/plain"); |
| expectedFiles.add("soup.txt"); |
| |
| container.addResource("<html><body><h1>Yo</h1></body></html>", |
| "soup.html", "text/html"); |
| expectedFiles.add("soup.html"); |
| |
| container.addResource("Sub-folder entry 1", "sub/1.txt", "text/plain"); |
| container.addResource("Sub-folder entry 2", "sub/2.txt", "text/plain"); |
| container.addResource("Sub-folder entry 2", "sub/3/woho.txt", |
| "text/plain"); |
| |
| container.addResource("Other sub-folder entry", "sub2/3.txt", |
| "text/plain"); |
| |
| expectedFiles.add("sub/"); |
| expectedSubFiles.add("1.txt"); |
| expectedSubFiles.add("2.txt"); |
| expectedSubFiles.add("3/"); |
| expectedSubSubFiles.add("woho.txt"); |
| expectedFiles.add("sub2/"); |
| |
| Map<String, ResourceEntry> beforeSaveRootEntries = container |
| .listResources(); |
| assertEquals(expectedFiles, beforeSaveRootEntries.keySet()); |
| |
| assertEquals(expectedSubFiles, container.listResources("sub").keySet()); |
| assertEquals(expectedSubFiles, container.listResources("sub/").keySet()); |
| assertEquals(expectedSubSubFiles, container.listResources("sub/3/") |
| .keySet()); |
| |
| container.save(tmpFile); |
| |
| UCFPackage loaded = new UCFPackage(tmpFile); |
| Map<String, ResourceEntry> loadedRootEntries = loaded.listResources(); |
| assertEquals(expectedFiles, loadedRootEntries.keySet()); |
| |
| assertEquals(expectedSubFiles, loaded.listResources("sub").keySet()); |
| assertEquals(expectedSubFiles, loaded.listResources("sub/").keySet()); |
| assertEquals(expectedSubSubFiles, loaded.listResources("sub/3/") |
| .keySet()); |
| } |
| |
| @Test |
| public void removeResource() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| |
| container.addResource("Soup for everyone", "soup.txt", "text/plain"); |
| |
| container.addResource("Sub-folder entry 1", "sub/1.txt", "text/plain"); |
| container.addResource("Sub-folder entry 2", "sub/2.txt", "text/plain"); |
| container.addResource("Sub-folder entry 2", "sub/3/woho.txt", |
| "text/plain"); |
| |
| assertTrue(container.listAllResources().keySet().contains("soup.txt")); |
| container.removeResource("soup.txt"); |
| assertFalse(container.listAllResources().keySet().contains("soup.txt")); |
| |
| try { |
| container.getResourceAsString("soup.txt"); |
| fail("Could still retrieve soup.txt"); |
| } catch (Exception ex) { |
| // OK |
| } |
| |
| container.save(tmpFile); |
| // reload |
| UCFPackage container2 = new UCFPackage(tmpFile); |
| |
| assertTrue(container2.listAllResources().keySet().contains("sub/")); |
| container2.removeResource("sub"); // should not work |
| assertTrue(container2.listAllResources().keySet().contains("sub/")); |
| assertTrue(container2.listAllResources().keySet().contains("sub/1.txt")); |
| |
| container2.removeResource("sub/"); |
| assertFalse(container2.listAllResources().keySet().contains("sub/")); |
| assertFalse(container2.listAllResources().keySet() |
| .contains("sub/1.txt")); |
| |
| container2.save(tmpFile); |
| |
| ZipFile zipFile = new ZipFile(tmpFile); |
| assertNull("soup.txt still in zip file", zipFile.getEntry("soup.txt")); |
| assertNull("sub/1.txt still in zip file", zipFile.getEntry("sub/1.txt")); |
| assertNull("sub/2.txt still in zip file", zipFile.getEntry("sub/2.txt")); |
| assertNull("sub/3.txt still in zip file", zipFile.getEntry("sub/3.txt")); |
| assertNull("sub/ still in zip file", zipFile.getEntry("sub/")); |
| zipFile.close(); |
| |
| UCFPackage loaded = new UCFPackage(tmpFile); |
| assertFalse(loaded.listAllResources().keySet().contains("soup.txt")); |
| assertFalse(loaded.listAllResources().keySet().contains("sub/")); |
| assertFalse(loaded.listAllResources().keySet().contains("sub/1.txt")); |
| |
| try { |
| loaded.getResourceAsString("sub/1.txt"); |
| fail("Could still retrieve soup.txt"); |
| } catch (Exception ex) { |
| // OK |
| } |
| loaded.save(tmpFile); |
| } |
| |
| @Test |
| public void fileListingRecursive() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| Set<String> expectedFiles = new HashSet<String>(); |
| |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| expectedFiles.add("helloworld.txt"); |
| |
| container.addResource("Soup for everyone", "soup.txt", "text/plain"); |
| expectedFiles.add("soup.txt"); |
| |
| container.addResource("<html><body><h1>Yo</h1></body></html>", |
| "soup.html", "text/html"); |
| expectedFiles.add("soup.html"); |
| |
| container.addResource("Sub-folder entry 1", "sub/1.txt", "text/plain"); |
| container.addResource("Sub-folder entry 2", "sub/2.txt", "text/plain"); |
| container.addResource("Sub-folder entry 2", "sub/3/woho.txt", |
| "text/plain"); |
| expectedFiles.add("sub/"); |
| expectedFiles.add("sub/1.txt"); |
| expectedFiles.add("sub/2.txt"); |
| expectedFiles.add("sub/3/"); |
| expectedFiles.add("sub/3/woho.txt"); |
| |
| Map<String, ResourceEntry> beforeSaveRootEntries = container |
| .listAllResources(); |
| |
| assertEquals(expectedFiles, beforeSaveRootEntries.keySet()); |
| |
| container.save(tmpFile); |
| |
| UCFPackage loaded = new UCFPackage(tmpFile); |
| Map<String, ResourceEntry> loadedRootEntries = loaded |
| .listAllResources(); |
| assertEquals(expectedFiles, loadedRootEntries.keySet()); |
| } |
| |
| @Test |
| public void resourceEntries() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| container.addResource("Sub-folder entry 1", "sub/1.txt", "text/plain"); |
| |
| ResourceEntry helloResource = container.listResources().get( |
| "helloworld.txt"); |
| assertEquals("helloworld.txt", helloResource.getPath()); |
| assertEquals(11, helloResource.getSize()); |
| assertEquals("text/plain", helloResource.getMediaType()); |
| |
| container.save(tmpFile); |
| |
| UCFPackage loaded = new UCFPackage(tmpFile); |
| |
| ResourceEntry loadedHelloResource = loaded.listResources().get( |
| "helloworld.txt"); |
| assertEquals("helloworld.txt", loadedHelloResource.getPath()); |
| assertEquals(11, loadedHelloResource.getSize()); |
| assertEquals("text/plain", loadedHelloResource.getMediaType()); |
| |
| } |
| |
| @Test |
| public void getResourceEntry() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| container.addResource("Sub-folder entry 1", "sub/1.txt", "text/plain"); |
| |
| ResourceEntry helloResource = container |
| .getResourceEntry("helloworld.txt"); |
| assertEquals("helloworld.txt", helloResource.getPath()); |
| assertEquals(11, helloResource.getSize()); |
| assertEquals("text/plain", helloResource.getMediaType()); |
| assertFalse(helloResource.isFolder()); |
| |
| ResourceEntry subResource = container.getResourceEntry("sub/"); |
| assertEquals("sub/", subResource.getPath()); |
| assertEquals(-1, subResource.getSize()); |
| assertEquals("text/plain", subResource.getMediaType()); |
| assertTrue(subResource.isFolder()); |
| |
| container.save(tmpFile); |
| |
| UCFPackage loaded = new UCFPackage(tmpFile); |
| |
| ResourceEntry loadedHelloResource = loaded |
| .getResourceEntry("helloworld.txt"); |
| assertEquals("helloworld.txt", loadedHelloResource.getPath()); |
| assertEquals(11, loadedHelloResource.getSize()); |
| assertEquals("text/plain", loadedHelloResource.getMediaType()); |
| assertFalse(loadedHelloResource.isFolder()); |
| |
| ResourceEntry loadedSubResource = loaded.getResourceEntry("sub/"); |
| assertEquals("sub/", loadedSubResource.getPath()); |
| assertEquals(-1, loadedSubResource.getSize()); |
| assertEquals("text/plain", loadedSubResource.getMediaType()); |
| assertTrue(loadedSubResource.isFolder()); |
| } |
| |
| @Test |
| public void manifestMimetype() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| |
| container.save(tmpFile); |
| ZipFile zipFile = new ZipFile(tmpFile); |
| ZipEntry manifestEntry = zipFile.getEntry("META-INF/manifest.xml"); |
| InputStream manifestStream = zipFile.getInputStream(manifestEntry); |
| |
| //System.out.println(IOUtils.toString(manifestStream, "UTF-8")); |
| /* |
| <?xml version="1.0" encoding="UTF-8"?> |
| <manifest:manifest xmlns:manifest="urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"> |
| </manifest:manifest> |
| */ |
| Document doc = parseXml(manifestStream); |
| assertEquals(MANIFEST_NS, doc.getRootElement().getNamespace()); |
| assertEquals("manifest", doc.getRootElement().getNamespacePrefix()); |
| assertEquals("manifest:manifest", doc.getRootElement().getQualifiedName()); |
| assertNull(xpathSelectElement(doc.getRootElement(), "/manifest:manifest/*")); |
| |
| } |
| |
| @Test |
| public void getRootfiles() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| assertTrue("Root files not empty", container.getRootFiles().isEmpty()); |
| assertNotSame("Should return copy of rootfiles", |
| container.getRootFiles(), container.getRootFiles()); |
| } |
| |
| @Test |
| public void setRootfile() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| container.addResource("Soup for everyone", "soup.txt", "text/plain"); |
| container.setRootFile("helloworld.txt"); |
| |
| List<ResourceEntry> rootFiles = container.getRootFiles(); |
| |
| assertEquals(1, rootFiles.size()); |
| ResourceEntry rootFile = rootFiles.get(0); |
| assertEquals("helloworld.txt", rootFile.getPath()); |
| assertEquals("text/plain", rootFile.getMediaType()); |
| } |
| |
| @Test |
| public void setRootfileSaved() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| container.addResource("Soup for everyone", "soup.txt", "text/plain"); |
| container.setRootFile("helloworld.txt"); |
| container.save(tmpFile); |
| |
| ZipFile zipFile = new ZipFile(tmpFile); |
| ZipEntry manifestEntry = zipFile.getEntry("META-INF/container.xml"); |
| InputStream manifestStream = zipFile.getInputStream(manifestEntry); |
| |
| |
| //System.out.println(IOUtils.toString(manifestStream, "UTF-8")); |
| /* |
| <?xml version="1.0" encoding="UTF-8" standalone="yes"?> |
| <container xmlns="urn:oasis:names:tc:opendocument:xmlns:container" xmlns:ns2="http://www.w3.org/2000/09/xmldsig#" xmlns:ns3="http://www.w3.org/2001/04/xmlenc#"> |
| <rootFiles> |
| <rootFile full-path="helloworld.txt" media-type="text/plain"/> |
| </rootFiles> |
| </container> |
| */ |
| Document doc = parseXml(manifestStream); |
| assertEquals(CONTAINER_NS, doc.getRootElement().getNamespace()); |
| |
| // Should work, but might still fail on Windows due to |
| // TAVERNA-920. We'll avoid testing this to not break the build. |
| // assertEquals("", doc.getRootElement().getNamespacePrefix()); |
| // assertEquals("container", doc.getRootElement().getQualifiedName()); |
| assertEquals("container", doc.getRootElement().getName()); |
| |
| assertXpathEquals("helloworld.txt", doc.getRootElement(), "/c:container/c:rootFiles/c:rootFile/@full-path"); |
| assertXpathEquals("text/plain", doc.getRootElement(), "/c:container/c:rootFiles/c:rootFile/@media-type"); |
| |
| } |
| |
| @Test |
| public void addResourceContainerXml() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| container.addResource("Soup for everyone", "soup.txt", "text/plain"); |
| container.setRootFile("helloworld.txt"); |
| assertEquals("helloworld.txt", container.getRootFiles().get(0) |
| .getPath()); |
| |
| String containerXml = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n" |
| + "<container xmlns=\"urn:oasis:names:tc:opendocument:xmlns:container\" xmlns:ns2=\"http://www.w3.org/2000/09/xmldsig#\" xmlns:ns3=\"http://www.w3.org/2001/04/xmlenc#\">\n" |
| + " <ex:example xmlns:ex=\"http://example.com/\">first example</ex:example>\n" |
| + " <rootFiles>\n" |
| + " <rootFile xmlns:ex=\"http://example.com/\" media-type=\"text/plain\" full-path=\"soup.txt\" ex:extraAnnotation=\"hello\"/>\n" |
| + " </rootFiles>\n" |
| + " <ex:example xmlns:ex=\"http://example.com/\">second example</ex:example>\n" |
| + " <ex:example xmlns:ex=\"http://example.com/\">third example</ex:example>\n" |
| + "</container>\n"; |
| // Should overwrite setRootFile() |
| container.addResource(containerXml, "META-INF/container.xml", |
| "text/xml"); |
| |
| assertEquals("soup.txt", container.getRootFiles().get(0).getPath()); |
| |
| container.save(tmpFile); |
| |
| ZipFile zipFile = new ZipFile(tmpFile); |
| ZipEntry manifestEntry = zipFile.getEntry("META-INF/container.xml"); |
| InputStream manifestStream = zipFile.getInputStream(manifestEntry); |
| |
| //System.out.println(IOUtils.toString(manifestStream, "UTF-8")); |
| /* |
| <?xml version="1.0" encoding="UTF-8" standalone="yes"?> |
| <container xmlns="urn:oasis:names:tc:opendocument:xmlns:container" xmlns:ns2="http://www.w3.org/2000/09/xmldsig#" xmlns:ns3="http://www.w3.org/2001/04/xmlenc#"> |
| <ex:example xmlns:ex="http://example.com/">first example</ex:example> |
| <rootFiles> |
| <rootFile xmlns:ex="http://example.com/" full-path="soup.txt" media-type="text/plain" ex:extraAnnotation="hello"/> |
| </rootFiles> |
| <ex:example xmlns:ex="http://example.com/">second example</ex:example> |
| <ex:example xmlns:ex="http://example.com/">third example</ex:example> |
| </container> |
| */ |
| Document doc = parseXml(manifestStream); |
| assertEquals(CONTAINER_NS, doc.getRootElement().getNamespace()); |
| |
| // Should work, but we'll ignore testing these (TAVERNA-920) |
| //assertEquals("", doc.getRootElement().getNamespacePrefix()); |
| //assertEquals("container", doc.getRootElement().getQualifiedName()); |
| assertEquals("container", doc.getRootElement().getName()); |
| |
| assertXpathEquals("soup.txt", doc.getRootElement(), "/c:container/c:rootFiles/c:rootFile[1]/@full-path"); |
| assertXpathEquals("text/plain", doc.getRootElement(), "/c:container/c:rootFiles/c:rootFile[1]/@media-type"); |
| assertXpathEquals("hello", doc.getRootElement(), "/c:container/c:rootFiles/c:rootFile[1]/@ex:extraAnnotation"); |
| |
| assertXpathEquals("first example", doc.getRootElement(), "/c:container/ex:example[1]"); |
| assertXpathEquals("second example", doc.getRootElement(), "/c:container/ex:example[2]"); |
| assertXpathEquals("third example", doc.getRootElement(), "/c:container/ex:example[3]"); |
| |
| // Check order |
| Element first = (Element) xpathSelectElement(doc.getRootElement(), "/c:container/*[1]"); |
| assertEquals("ex:example", first.getQualifiedName()); |
| Element second = (Element) xpathSelectElement(doc.getRootElement(), "/c:container/*[2]"); |
| |
| // Should work, but we'll ignore testing these (TAVERNA-920) |
| //assertEquals("rootFiles", second.getQualifiedName()); |
| assertEquals("rootFiles", second.getName()); |
| |
| Element third = (Element) xpathSelectElement(doc.getRootElement(), "/c:container/*[3]"); |
| assertEquals("ex:example", third.getQualifiedName()); |
| Element fourth = (Element) xpathSelectElement(doc.getRootElement(), "/c:container/*[4]"); |
| assertEquals("ex:example", fourth.getQualifiedName()); |
| |
| |
| |
| } |
| |
| @Test |
| public void setRootfileExtendsContainerXml() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| container.addResource("<html><body><h1>Yo</h1></body></html>", |
| "helloworld.html", "text/html"); |
| |
| String containerXml = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n" |
| + "<container xmlns=\"urn:oasis:names:tc:opendocument:xmlns:container\" xmlns:ex='http://example.com/' xmlns:ns2=\"http://www.w3.org/2000/09/xmldsig#\" xmlns:ns3=\"http://www.w3.org/2001/04/xmlenc#\">\n" |
| + " <rootFiles>\n" |
| + " <rootFile ex:extraAnnotation='hello' media-type=\"text/html\" full-path=\"helloworld.html\"/>\n" |
| + " </rootFiles>\n" |
| + " <ex:example>more example</ex:example>\n" |
| + "</container>\n"; |
| // Should overwrite setRootFile() |
| container.addResource(containerXml, "META-INF/container.xml", |
| "text/xml"); |
| assertEquals("helloworld.html", container.getRootFiles().get(0) |
| .getPath()); |
| |
| container.setRootFile("helloworld.txt"); |
| assertEquals("helloworld.html", container.getRootFiles().get(0) |
| .getPath()); |
| assertEquals("helloworld.txt", container.getRootFiles().get(1) |
| .getPath()); |
| container.save(tmpFile); |
| // |
| // String expectedContainerXml = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n" |
| // + "<container xmlns=\"urn:oasis:names:tc:opendocument:xmlns:container\" xmlns:ns2=\"http://www.w3.org/2000/09/xmldsig#\" xmlns:ns3=\"http://www.w3.org/2001/04/xmlenc#\">\n" |
| // + " <rootFiles>\n" |
| // + " <rootFile xmlns:ex=\"http://example.com/\" media-type=\"text/html\" full-path=\"helloworld.html\" ex:extraAnnotation=\"hello\"/>\n" |
| // + " <rootFile media-type=\"text/plain\" full-path=\"helloworld.txt\"/>\n" |
| // + " </rootFiles>\n" |
| // + " <ex:example xmlns:ex=\"http://example.com/\">more example</ex:example>\n" |
| // + |
| // "</container>\n"; |
| |
| ZipFile zipFile = new ZipFile(tmpFile); |
| ZipEntry manifestEntry = zipFile.getEntry("META-INF/container.xml"); |
| InputStream manifestStream = zipFile.getInputStream(manifestEntry); |
| |
| //System.out.println(IOUtils.toString(manifestStream, "UTF-8")); |
| /* |
| <?xml version="1.0" encoding="UTF-8" standalone="yes"?> |
| <container xmlns="urn:oasis:names:tc:opendocument:xmlns:container" xmlns:ns2="http://www.w3.org/2000/09/xmldsig#" xmlns:ns3="http://www.w3.org/2001/04/xmlenc#"> |
| <rootFiles> |
| <rootFile xmlns:ex="http://example.com/" full-path="helloworld.html" media-type="text/html" ex:extraAnnotation="hello"/> |
| <rootFile full-path="helloworld.txt" media-type="text/plain"/> |
| </rootFiles> |
| <ex:example xmlns:ex="http://example.com/">more example</ex:example> |
| </container> |
| */ |
| Document doc = parseXml(manifestStream); |
| assertEquals(CONTAINER_NS, doc.getRootElement().getNamespace()); |
| // Should work, but we'll avoid testing it (TAVERNA-920) |
| //assertEquals("", doc.getRootElement().getNamespacePrefix()); |
| //assertEquals("container", doc.getRootElement().getQualifiedName()); |
| assertEquals("container", doc.getRootElement().getName()); |
| assertXpathEquals("helloworld.html", doc.getRootElement(), "/c:container/c:rootFiles/c:rootFile[1]/@full-path"); |
| assertXpathEquals("text/html", doc.getRootElement(), "/c:container/c:rootFiles/c:rootFile[1]/@media-type"); |
| assertXpathEquals("hello", doc.getRootElement(), "/c:container/c:rootFiles/c:rootFile[1]/@ex:extraAnnotation"); |
| |
| |
| assertXpathEquals("helloworld.txt", doc.getRootElement(), "/c:container/c:rootFiles/c:rootFile[2]/@full-path"); |
| assertXpathEquals("text/plain", doc.getRootElement(), "/c:container/c:rootFiles/c:rootFile[2]/@media-type"); |
| |
| assertXpathEquals("more example", doc.getRootElement(), "/c:container/ex:example"); |
| |
| // Check order |
| Element first = (Element) xpathSelectElement(doc.getRootElement(), "/c:container/*[1]"); |
| //assertEquals("rootFiles", first.getQualifiedName()); |
| assertEquals("rootFiles", first.getName()); |
| Element second = (Element) xpathSelectElement(doc.getRootElement(), "/c:container/*[2]"); |
| assertEquals("ex:example", second.getQualifiedName()); |
| |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void setRootfileMissing() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| try { |
| container.setRootFile("unknown.txt"); |
| } finally { |
| assertTrue("Should not have added unknown.txt", container |
| .getRootFiles().isEmpty()); |
| } |
| |
| } |
| |
| @Test |
| public void unmodifiableRootFiles() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| container.setRootFile("helloworld.txt"); |
| List<ResourceEntry> rootFiles = container.getRootFiles(); |
| assertEquals(1, rootFiles.size()); |
| rootFiles.remove(0); |
| assertEquals(0, rootFiles.size()); |
| assertEquals("Should not be able to modify rootFiles list", 1, |
| container.getRootFiles().size()); |
| } |
| |
| |
| @Test |
| public void rootFileVersion() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| container.setRootFile("helloworld.txt", "1.2.3"); |
| container.save(tmpFile); |
| UCFPackage reloaded = new UCFPackage(tmpFile); |
| ResourceEntry rootFile = reloaded.getRootFiles().get(0); |
| assertEquals("helloworld.txt", rootFile.getPath()); |
| assertEquals("1.2.3", reloaded.getRootFileVersion("helloworld.txt")); |
| } |
| |
| @Test |
| public void rootFileVersionNull() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| container.setRootFile("helloworld.txt", "1.2.3"); |
| container.save(tmpFile); |
| UCFPackage reloaded = new UCFPackage(tmpFile); |
| reloaded.setRootFile("helloworld.txt"); |
| reloaded.save(tmpFile); |
| @SuppressWarnings("unused") |
| UCFPackage again = new UCFPackage(tmpFile); |
| assertNull(reloaded.getRootFileVersion("helloworld.txt")); |
| } |
| |
| @Test |
| public void multipleRootfiles() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| container.addResource("<html><body><h1>Yo</h1></body></html>", |
| "helloworld.html", "text/html"); |
| container.addResource("Soup for everyone", "soup.txt", "text/plain"); |
| container.setRootFile("helloworld.txt"); |
| // Adding a second file of a different mime type |
| container.setRootFile("helloworld.html"); |
| List<ResourceEntry> rootFiles = container.getRootFiles(); |
| assertEquals(2, rootFiles.size()); |
| |
| ResourceEntry rootFile0 = rootFiles.get(0); |
| assertEquals("helloworld.txt", rootFile0.getPath()); |
| assertEquals("text/plain", rootFile0.getMediaType()); |
| |
| ResourceEntry rootFile1 = rootFiles.get(1); |
| assertEquals("helloworld.html", rootFile1.getPath()); |
| assertEquals("text/html", rootFile1.getMediaType()); |
| } |
| |
| @Test |
| public void multipleRootfilesReloaded() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| container.addResource("<html><body><h1>Yo</h1></body></html>", |
| "helloworld.html", "text/html"); |
| container.addResource("Soup for everyone", "soup.txt", "text/plain"); |
| container.setRootFile("helloworld.txt"); |
| // Adding a second file of a different mime type |
| container.setRootFile("helloworld.html"); |
| |
| container.save(tmpFile); |
| UCFPackage reloaded = new UCFPackage(tmpFile); |
| |
| List<ResourceEntry> rootFiles = reloaded.getRootFiles(); |
| assertEquals(2, rootFiles.size()); |
| |
| ResourceEntry rootFile0 = rootFiles.get(0); |
| assertEquals("helloworld.txt", rootFile0.getPath()); |
| assertEquals("text/plain", rootFile0.getMediaType()); |
| |
| ResourceEntry rootFile1 = rootFiles.get(1); |
| assertEquals("helloworld.html", rootFile1.getPath()); |
| assertEquals("text/html", rootFile1.getMediaType()); |
| } |
| |
| @Test |
| public void unsetMultipleRootFiles() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| container.addResource("<html><body><h1>Yo</h1></body></html>", |
| "helloworld.html", "text/html"); |
| container.addResource("Soup for everyone", "soup.txt", "text/plain"); |
| container.setRootFile("helloworld.txt"); |
| container.setRootFile("helloworld.html"); |
| List<ResourceEntry> rootFiles = container.getRootFiles(); |
| assertEquals(2, rootFiles.size()); |
| |
| container.unsetRootFile("helloworld.txt"); |
| rootFiles = container.getRootFiles(); |
| assertEquals(1, rootFiles.size()); |
| |
| ResourceEntry rootFile0 = rootFiles.get(0); |
| assertEquals("helloworld.html", rootFile0.getPath()); |
| assertEquals("text/html", rootFile0.getMediaType()); |
| } |
| |
| @Test |
| public void unsetRootFile() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| container.addResource("Soup for everyone", "soup.txt", "text/plain"); |
| container.setRootFile("helloworld.txt"); |
| assertEquals(1, container.getRootFiles().size()); |
| container.unsetRootFile("helloworld.txt"); |
| assertEquals(0, container.getRootFiles().size()); |
| } |
| |
| @Test |
| public void cloneUcfPackage() throws Exception { |
| UCFPackage container = new UCFPackage(); |
| container.setPackageMediaType(UCFPackage.MIME_WORKFLOW_BUNDLE); |
| container.addResource("Hello there", "helloworld.txt", "text/plain"); |
| container.addResource("Soup for everyone", "soup.txt", "text/plain"); |
| container.setRootFile("helloworld.txt"); |
| assertEquals(2, container.listAllResources().size()); |
| |
| UCFPackage clone = container.clone(); |
| |
| // Change the original to ensure independence |
| container.setPackageMediaType("text/other"); |
| container.removeResource("soup.txt"); |
| container.addResource("Something else", "helloworld.txt", "test/other"); |
| container.addResource("extra", "extra1.txt", "text/plain"); |
| container.addResource("extra", "extra2.txt", "text/plain"); |
| container.setRootFile("extra1.txt"); |
| |
| assertEquals(UCFPackage.MIME_WORKFLOW_BUNDLE, clone.getPackageMediaType()); |
| assertEquals("Hello there", clone.getResourceAsString("helloworld.txt")); |
| ResourceEntry helloWorldEntry = clone.getResourceEntry("helloworld.txt"); |
| assertEquals("text/plain", helloWorldEntry.getMediaType()); |
| assertEquals("Soup for everyone", clone.getResourceAsString("soup.txt")); |
| assertEquals(Arrays.asList(helloWorldEntry), clone.getRootFiles()); |
| assertEquals(2, clone.listAllResources().size()); |
| } |
| |
| } |
