org.argeo.core/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.RepositoryException;
  17 import javax.jcr.Session;
  18 import javax.jcr.nodetype.NodeType;
  19
  20 import org.apache.commons.io.IOUtils;
  21 import org.apache.commons.logging.Log;
  22 import org.apache.commons.logging.LogFactory;
  23 import org.apache.jackrabbit.core.RepositoryImpl;
  24 import org.argeo.jackrabbit.fs.JackrabbitMemoryFsProvider;
  25
  26 import junit.framework.TestCase;
  27
  28 public class JcrFileSystemTest extends TestCase {
  29         private final static Log log = LogFactory.getLog(JcrFileSystemTest.class);
  30
  31         public void testMounts() throws Exception {
  32                 JackrabbitMemoryFsProvider fsProvider = new JackrabbitMemoryFsProvider() {
  33
  34                         @Override
  35                         protected void postRepositoryCreation(RepositoryImpl repositoryImpl) throws RepositoryException {
  36                                 // create workspace
  37                                 Session session = login();
  38                                 session.getWorkspace().createWorkspace("test");
  39                         }
  40
  41                 };
  42
  43                 Path rootPath = fsProvider.getPath(new URI("jcr+memory:/"));
  44                 log.debug("Got root " + rootPath);
  45                 Path testDir = rootPath.resolve("testDir");
  46                 Files.createDirectory(testDir);
  47
  48                 Path testMount = fsProvider.getPath(new URI("jcr+memory:/test"));
  49                 log.debug("Test path");
  50                 assertEquals(rootPath, testMount.getParent());
  51                 assertEquals(testMount.getFileName(), rootPath.relativize(testMount));
  52
  53                 Path testPath = testMount.resolve("test.txt");
  54                 log.debug("Create file " + testPath);
  55                 Files.createFile(testPath);
  56                 BasicFileAttributes bfa = Files.readAttributes(testPath, BasicFileAttributes.class);
  57                 FileTime ft = bfa.creationTime();
  58                 assertNotNull(ft);
  59                 assertTrue(bfa.isRegularFile());
  60                 log.debug("Created " + testPath + " (" + ft + ")");
  61                 Files.delete(testPath);
  62                 log.debug("Deleted " + testPath);
  63
  64                 // Browse directories from root
  65                 DirectoryStream<Path> files = Files.newDirectoryStream(rootPath);
  66                 int directoryCount = 0;
  67                 for (Path file : files) {
  68                         if (Files.isDirectory(file)) {
  69                                 directoryCount++;
  70                         }
  71                 }
  72                 assertEquals(2, directoryCount);
  73
  74                 // Browse directories from mount
  75                 Path mountSubDir = testMount.resolve("mountSubDir");
  76                 Files.createDirectory(mountSubDir);
  77                 Path otherSubDir = testMount.resolve("otherSubDir");
  78                 Files.createDirectory(otherSubDir);
  79                 testPath = testMount.resolve("test.txt");
  80                 Files.createFile(testPath);
  81                 files = Files.newDirectoryStream(testMount);
  82                 int fileCount = 0;
  83                 for (Path file : files) {
  84                         fileCount++;
  85                 }
  86                 assertEquals(3, fileCount);
  87
  88         }
  89
  90         public void testSimple() throws Exception {
  91                 FileSystemProvider fsProvider = new JackrabbitMemoryFsProvider();
  92
  93                 // Simple file
  94                 Path rootPath = fsProvider.getPath(new URI("jcr+memory:/"));
  95                 log.debug("Got root " + rootPath);
  96                 Path testPath = fsProvider.getPath(new URI("jcr+memory:/test.txt"));
  97                 log.debug("Test path");
  98                 assertEquals("test.txt", testPath.getFileName().toString());
  99                 assertEquals(rootPath, testPath.getParent());
 100                 assertEquals(testPath.getFileName(), rootPath.relativize(testPath));
 101                 // relativize self should be empty path
 102                 Path selfRelative = testPath.relativize(testPath);
 103                 assertEquals("", selfRelative.toString());
 104
 105                 log.debug("Create file " + testPath);
 106                 Files.createFile(testPath);
 107                 BasicFileAttributes bfa = Files.readAttributes(testPath, BasicFileAttributes.class);
 108                 FileTime ft = bfa.creationTime();
 109                 assertNotNull(ft);
 110                 assertTrue(bfa.isRegularFile());
 111                 log.debug("Created " + testPath + " (" + ft + ")");
 112                 Files.delete(testPath);
 113                 log.debug("Deleted " + testPath);
 114                 String txt = "TEST\nTEST2\n";
 115                 byte[] arr = txt.getBytes();
 116                 Files.write(testPath, arr);
 117                 log.debug("Wrote " + testPath);
 118                 byte[] read = Files.readAllBytes(testPath);
 119                 assertTrue(Arrays.equals(arr, read));
 120                 assertEquals(txt, new String(read));
 121                 log.debug("Read " + testPath);
 122                 Path testDir = rootPath.resolve("testDir");
 123                 log.debug("Resolved " + testDir);
 124                 // Copy
 125                 Files.createDirectory(testDir);
 126                 log.debug("Created directory " + testDir);
 127                 Path subsubdir = Files.createDirectories(testDir.resolve("subdir/subsubdir"));
 128                 log.debug("Created sub directories " + subsubdir);
 129                 Path copiedFile = testDir.resolve("copiedFile.txt");
 130                 log.debug("Resolved " + copiedFile);
 131                 Path relativeCopiedFile = testDir.relativize(copiedFile);
 132                 assertEquals(copiedFile.getFileName().toString(), relativeCopiedFile.toString());
 133                 log.debug("Relative copied file " + relativeCopiedFile);
 134                 try (OutputStream out = Files.newOutputStream(copiedFile); InputStream in = Files.newInputStream(testPath)) {
 135                         IOUtils.copy(in, out);
 136                 }
 137                 log.debug("Copied " + testPath + " to " + copiedFile);
 138                 Files.delete(testPath);
 139                 log.debug("Deleted " + testPath);
 140                 byte[] copiedRead = Files.readAllBytes(copiedFile);
 141                 assertTrue(Arrays.equals(copiedRead, read));
 142                 log.debug("Read " + copiedFile);
 143                 // Browse directories
 144                 DirectoryStream<Path> files = Files.newDirectoryStream(testDir);
 145                 int fileCount = 0;
 146                 Path listedFile = null;
 147                 for (Path file : files) {
 148                         fileCount++;
 149                         if (!Files.isDirectory(file))
 150                                 listedFile = file;
 151                 }
 152                 assertEquals(2, fileCount);
 153                 assertEquals(copiedFile, listedFile);
 154                 assertEquals(copiedFile.toString(), listedFile.toString());
 155                 log.debug("Listed " + testDir);
 156                 // Generic attributes
 157                 Map<String, Object> attrs = Files.readAttributes(copiedFile, "*");
 158                 assertEquals(3, attrs.size());
 159                 log.debug("Read attributes of " + copiedFile + ": " + attrs.keySet());
 160                 // Direct node access
 161                 NodeFileAttributes nfa = Files.readAttributes(copiedFile, NodeFileAttributes.class);
 162                 nfa.getNode().addMixin(NodeType.MIX_LANGUAGE);
 163                 nfa.getNode().getSession().save();
 164                 log.debug("Add mix:language");
 165                 Files.setAttribute(copiedFile, Property.JCR_LANGUAGE, "fr");
 166                 log.debug("Set language");
 167                 attrs = Files.readAttributes(copiedFile, "*");
 168                 assertEquals(4, attrs.size());
 169                 log.debug("Read attributes of " + copiedFile + ": " + attrs.keySet());
 170         }
 171
 172         public void testIllegalCharacters() throws Exception {
 173                 FileSystemProvider fsProvider = new JackrabbitMemoryFsProvider();
 174                 String fileName = "tüßçt[1].txt";
 175                 String pathStr = "/testDir/" + fileName;
 176                 Path testDir = fsProvider.getPath(new URI("jcr+memory:/testDir"));
 177                 Files.createDirectory(testDir);
 178                 Path testPath = testDir.resolve(fileName);
 179                 assertEquals(pathStr, testPath.toString());
 180                 Files.createFile(testPath);
 181                 DirectoryStream<Path> files = Files.newDirectoryStream(testDir);
 182                 Path listedPath = files.iterator().next();
 183                 assertEquals(pathStr, listedPath.toString());
 184
 185                 String dirName = "*[~WeirdDir~]*";
 186                 Path subDir = testDir.resolve(dirName);
 187                 Files.createDirectory(subDir);
 188                 subDir = testDir.resolve(dirName);
 189                 assertEquals(dirName, subDir.getFileName().toString());
 190         }
 191 }