nameshortening tests

main/filesystem-nameshortening/src/main/java/org/cryptomator/filesystem/blacklisting/SamePathPredicate.java

@@ -0,0 +1,26 @@
+package org.cryptomator.filesystem.blacklisting;
+
+import java.util.Objects;
+import java.util.function.Predicate;
+
+import org.cryptomator.filesystem.Node;
+
+public class SamePathPredicate implements Predicate<Node> {
+
+	private final Node node;
+
+	private SamePathPredicate(Node node) {
+		Objects.requireNonNull(node);
+		this.node = node;
+	}
+
+	@Override
+	public boolean test(Node other) {
+		return node.parent().equals(other.parent()) && node.name().equals(other.name());
+	}
+
+	public static SamePathPredicate forNode(Node node) {
+		return new SamePathPredicate(node);
+	}
+
+}

main/filesystem-nameshortening/src/main/java/org/cryptomator/filesystem/shortening/ShorteningFileSystemFactory.java

@@ -1,14 +1,12 @@
 package org.cryptomator.filesystem.shortening;
 
-import java.util.function.Predicate;
-
 import javax.inject.Inject;
 import javax.inject.Singleton;
 
 import org.cryptomator.filesystem.FileSystem;
 import org.cryptomator.filesystem.Folder;
-import org.cryptomator.filesystem.Node;
 import org.cryptomator.filesystem.blacklisting.BlacklistingFileSystemFactory;
+import org.cryptomator.filesystem.blacklisting.SamePathPredicate;
 
 @Singleton
 public class ShorteningFileSystemFactory {
@@ -25,8 +23,7 @@ public class ShorteningFileSystemFactory {
 
 	public FileSystem get(Folder root) {
 		final Folder metadataFolder = root.folder(METADATA_FOLDER_NAME);
-		final Predicate<Node> isMetadataFolder = (Node node) -> metadataFolder.equals(node);
-		final FileSystem metadataHidingFs = blacklistingFileSystemFactory.get(root, isMetadataFolder);
+		final FileSystem metadataHidingFs = blacklistingFileSystemFactory.get(root, SamePathPredicate.forNode(metadataFolder));
 		return new ShorteningFileSystem(metadataHidingFs, metadataFolder, SHORTENING_THRESHOLD);
 	}
 }

main/filesystem-nameshortening/src/test/java/org/cryptomator/filesystem/blacklisting/BlacklistingFileSystemTest.java

@@ -18,12 +18,19 @@ import org.junit.Test;
 public class BlacklistingFileSystemTest {
 
 	@Test(expected = UncheckedIOException.class)
-	public void testPreventCreationOfMetadataFolder() {
+	public void testPreventCreationOfBlacklistedFolder() {
 		final FileSystem underlyingFs = new InMemoryFileSystem();
-		final Folder metadataRoot = underlyingFs.folder("m");
-		final Predicate<Node> metadataHidden = (Node n) -> n.equals(metadataRoot);
-		final FileSystem fs = new BlacklistingFileSystem(underlyingFs, metadataHidden);
-		fs.folder("m");
+		final Node blacklisted = underlyingFs.folder("qwe");
+		final FileSystem fs = new BlacklistingFileSystem(underlyingFs, SamePathPredicate.forNode(blacklisted));
+		fs.folder("qwe");
+	}
+
+	@Test(expected = UncheckedIOException.class)
+	public void testPreventCreationOBlacklistedFile() {
+		final FileSystem underlyingFs = new InMemoryFileSystem();
+		final Node blacklisted = underlyingFs.folder("qwe");
+		final FileSystem fs = new BlacklistingFileSystem(underlyingFs, SamePathPredicate.forNode(blacklisted));
+		fs.file("qwe");
 	}
 
 	@Test
@@ -33,8 +40,8 @@ public class BlacklistingFileSystemTest {
 		final File hiddenFile = underlyingFs.file("qwe");
 		final Folder visibleFolder = underlyingFs.folder("sdf");
 		final File visibleFile = underlyingFs.file("wer");
-		final Predicate<Node> metadataHidden = (Node n) -> n.equals(hiddenFolder) || n.equals(hiddenFile);
-		final FileSystem fs = new BlacklistingFileSystem(underlyingFs, metadataHidden);
+		final Predicate<Node> hiddenPredicate = SamePathPredicate.forNode(hiddenFolder).or(SamePathPredicate.forNode(hiddenFile));
+		final FileSystem fs = new BlacklistingFileSystem(underlyingFs, hiddenPredicate);
 		hiddenFolder.create();
 		try (WritableByteChannel writable = hiddenFile.openWritable()) {
 			writable.write(ByteBuffer.allocate(0));
@@ -46,6 +53,7 @@ public class BlacklistingFileSystemTest {
 
 		Assert.assertArrayEquals(new String[] {"sdf"}, fs.folders().map(Node::name).collect(Collectors.toList()).toArray());
 		Assert.assertArrayEquals(new String[] {"wer"}, fs.files().map(Node::name).collect(Collectors.toList()).toArray());
+		Assert.assertArrayEquals(new String[] {"sdf", "wer"}, fs.children().map(Node::name).sorted().collect(Collectors.toList()).toArray());
 	}
 
 }

main/filesystem-nameshortening/src/test/java/org/cryptomator/filesystem/blacklisting/SamePathPredicateTest.java

@@ -0,0 +1,36 @@
+package org.cryptomator.filesystem.blacklisting;
+
+import org.cryptomator.filesystem.File;
+import org.cryptomator.filesystem.FileSystem;
+import org.cryptomator.filesystem.Folder;
+import org.cryptomator.filesystem.inmem.InMemoryFileSystem;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SamePathPredicateTest {
+
+	@Test
+	public void testFileAndFolderWithSameNameWithSameParentConsideredSame() {
+		FileSystem fs = new InMemoryFileSystem();
+		File file1 = fs.file("foo");
+		Folder folder1 = fs.folder("foo");
+		Assert.assertTrue(SamePathPredicate.forNode(file1).test(folder1));
+	}
+
+	@Test
+	public void testFilesWithDifferentParentConsideredDifferent() {
+		FileSystem fs = new InMemoryFileSystem();
+		File file1 = fs.file("foo");
+		File file2 = fs.folder("bar").file("foo");
+		Assert.assertFalse(SamePathPredicate.forNode(file1).test(file2));
+	}
+
+	@Test
+	public void testFilesWithDifferentNamesConsideredDifferent() {
+		FileSystem fs = new InMemoryFileSystem();
+		File file1 = fs.file("foo");
+		File file2 = fs.file("bar");
+		Assert.assertFalse(SamePathPredicate.forNode(file1).test(file2));
+	}
+
+}

main/filesystem-nameshortening/src/test/java/org/cryptomator/filesystem/shortening/FilenameShortenerTest.java

@@ -0,0 +1,48 @@
+package org.cryptomator.filesystem.shortening;
+
+import java.io.UncheckedIOException;
+
+import org.cryptomator.filesystem.FileSystem;
+import org.cryptomator.filesystem.inmem.InMemoryFileSystem;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class FilenameShortenerTest {
+
+	@Test
+	public void testNoDeflationOfShortFiles() {
+		FileSystem fs = new InMemoryFileSystem();
+		FilenameShortener shortener = new FilenameShortener(fs, 10);
+		Assert.assertEquals("short", shortener.deflate("short"));
+	}
+
+	@Test
+	public void testDeflateAndInflate() {
+		FileSystem fs = new InMemoryFileSystem();
+		FilenameShortener shortener = new FilenameShortener(fs, 10);
+
+		String longName = "suchALongName";
+		String shortenedName = shortener.deflate(longName);
+		shortener.saveMapping(longName, shortenedName);
+		Assert.assertNotEquals(longName, shortenedName);
+
+		Assert.assertEquals(longName, shortener.inflate(shortenedName));
+	}
+
+	@Test
+	public void testNoInflationOfShortFiles() {
+		FileSystem fs = new InMemoryFileSystem();
+		FilenameShortener shortener = new FilenameShortener(fs, 10);
+
+		Assert.assertEquals("short", shortener.inflate("short"));
+	}
+
+	@Test(expected = UncheckedIOException.class)
+	public void testInflateWithoutMappingFile() {
+		FileSystem fs = new InMemoryFileSystem();
+		FilenameShortener shortener = new FilenameShortener(fs, 10);
+
+		shortener.inflate("iJustMadeThisNameUp.lng");
+	}
+
+}