org.argeo.jcr/ext/test/org/argeo/jcr/fs/JcrFileSystemTest.java

   1 package org.argeo.jcr.fs;
   2
   3 import java.io.InputStream;
   4 import java.io.OutputStream;
   5 import java.net.URI;
   6 import java.nio.file.DirectoryStream;
   7 import java.nio.file.Files;
   8 import java.nio.file.Path;
   9 import java.nio.file.attribute.BasicFileAttributes;
  10 import java.nio.file.attribute.FileTime;
  11 import java.nio.file.spi.FileSystemProvider;
  12 import java.util.Arrays;
  13 import java.util.Map;
  14
  15 import javax.jcr.Property;
  16 import javax.jcr.nodetype.NodeType;
  17
  18 import org.apache.commons.io.IOUtils;
  19 import org.apache.commons.logging.Log;
  20 import org.apache.commons.logging.LogFactory;
  21 import org.argeo.jackrabbit.fs.JackrabbitMemoryFsProvider;
  22
  23 import junit.framework.TestCase;
  24
  25 public class JcrFileSystemTest extends TestCase {
  26         private final static Log log = LogFactory.getLog(JcrFileSystemTest.class);
  27
  28         public void testSimple() throws Exception {
  29                 FileSystemProvider fsProvider = new JackrabbitMemoryFsProvider();
  30
  31                 // Simple file
  32                 Path rootPath = fsProvider.getPath(new URI("jcr+memory:/"));
  33                 log.debug("Got root " + rootPath);
  34                 Path testPath = fsProvider.getPath(new URI("jcr+memory:/test.txt"));
  35                 log.debug("Test path");
  36                 assertEquals("test.txt", testPath.getFileName().toString());
  37                 assertEquals(rootPath, testPath.getParent());
  38                 assertEquals(testPath.getFileName(), rootPath.relativize(testPath));
  39                 // relativize self should be empty path
  40                 Path selfRelative = testPath.relativize(testPath);
  41                 assertEquals("", selfRelative.toString());
  42
  43                 log.debug("Create file " + testPath);
  44                 Files.createFile(testPath);
  45                 BasicFileAttributes bfa = Files.readAttributes(testPath, BasicFileAttributes.class);
  46                 FileTime ft = bfa.creationTime();
  47                 assertNotNull(ft);
  48                 assertTrue(bfa.isRegularFile());
  49                 log.debug("Created " + testPath + " (" + ft + ")");
  50                 Files.delete(testPath);
  51                 log.debug("Deleted " + testPath);
  52                 String txt = "TEST\nTEST2\n";
  53                 byte[] arr = txt.getBytes();
  54                 Files.write(testPath, arr);
  55                 log.debug("Wrote " + testPath);
  56                 byte[] read = Files.readAllBytes(testPath);
  57                 assertTrue(Arrays.equals(arr, read));
  58                 assertEquals(txt, new String(read));
  59                 log.debug("Read " + testPath);
  60                 Path testDir = rootPath.resolve("testDir");
  61                 log.debug("Resolved " + testDir);
  62                 // Copy
  63                 Files.createDirectory(testDir);
  64                 log.debug("Created directory " + testDir);
  65                 Path subsubdir = Files.createDirectories(testDir.resolve("subdir/subsubdir"));
  66                 log.debug("Created sub directories " + subsubdir);
  67                 Path copiedFile = testDir.resolve("copiedFile.txt");
  68                 log.debug("Resolved " + copiedFile);
  69                 Path relativeCopiedFile = testDir.relativize(copiedFile);
  70                 assertEquals(copiedFile.getFileName().toString(), relativeCopiedFile.toString());
  71                 log.debug("Relative copied file " + relativeCopiedFile);
  72                 try (OutputStream out = Files.newOutputStream(copiedFile); InputStream in = Files.newInputStream(testPath)) {
  73                         IOUtils.copy(in, out);
  74                 }
  75                 log.debug("Copied " + testPath + " to " + copiedFile);
  76                 Files.delete(testPath);
  77                 log.debug("Deleted " + testPath);
  78                 byte[] copiedRead = Files.readAllBytes(copiedFile);
  79                 assertTrue(Arrays.equals(copiedRead, read));
  80                 log.debug("Read " + copiedFile);
  81                 // Browse directories
  82                 DirectoryStream<Path> files = Files.newDirectoryStream(testDir);
  83                 int fileCount = 0;
  84                 Path listedFile = null;
  85                 for (Path file : files) {
  86                         fileCount++;
  87                         if (!Files.isDirectory(file))
  88                                 listedFile = file;
  89                 }
  90                 assertEquals(2, fileCount);
  91                 assertEquals(copiedFile, listedFile);
  92                 assertEquals(copiedFile.toString(), listedFile.toString());
  93                 log.debug("Listed " + testDir);
  94                 // Generic attributes
  95                 Map<String, Object> attrs = Files.readAttributes(copiedFile, "*");
  96                 assertEquals(5, attrs.size());
  97                 log.debug("Read attributes of " + copiedFile + ": " + attrs.keySet());
  98                 // Direct node access
  99                 NodeFileAttributes nfa = Files.readAttributes(copiedFile, NodeFileAttributes.class);
 100                 nfa.getNode().addMixin(NodeType.MIX_LANGUAGE);
 101                 nfa.getNode().getSession().save();
 102                 log.debug("Add mix:language");
 103                 Files.setAttribute(copiedFile, Property.JCR_LANGUAGE, "fr");
 104                 log.debug("Set language");
 105                 attrs = Files.readAttributes(copiedFile, "*");
 106                 assertEquals(6, attrs.size());
 107                 log.debug("Read attributes of " + copiedFile + ": " + attrs.keySet());
 108         }
 109
 110         public void testIllegalCharacters() throws Exception {
 111                 FileSystemProvider fsProvider = new JackrabbitMemoryFsProvider();
 112                 String fileName = "tüßçt[1].txt";
 113                 String pathStr = "/testDir/" + fileName;
 114                 Path testDir = fsProvider.getPath(new URI("jcr+memory:/testDir"));
 115                 Files.createDirectory(testDir);
 116                 Path testPath = testDir.resolve(fileName);
 117                 assertEquals(pathStr, testPath.toString());
 118                 Files.createFile(testPath);
 119                 DirectoryStream<Path> files = Files.newDirectoryStream(testDir);
 120                 Path listedPath = files.iterator().next();
 121                 assertEquals(pathStr, listedPath.toString());
 122
 123                 String dirName = "*[~WeirdDir~]*";
 124                 Path subDir = testDir.resolve(dirName);
 125                 Files.createDirectory(subDir);
 126                 subDir = testDir.resolve(dirName);
 127                 assertEquals(dirName, subDir.getFileName().toString());
 128         }
 129 }