* Implements means to throw checked exceptions crossing method boundaries which do not declare them. @@ -35,9 +37,7 @@ public T from(Supplier action) throws E { allowedToBeThrownUnchecked.addFirst(type); return action.get(); } catch (ExceptionThrownUnchecked e) { - if (type.isInstance(e.getCause())) { - throw type.cast(e.getCause()); - } + Throwables.throwIfInstanceOf(e.getCause(), type); throw e; } finally { allowedToBeThrownUnchecked.removeFirst(); @@ -56,9 +56,8 @@ public static RethrowUncheckedWithoutAction rethrowUnch public T from(SupplierThrowingException action) { try { return action.get(); - } catch (RuntimeException e) { - throw e; // don't catch unchecked exceptions } catch (Exception e) { + Throwables.throwIfUnchecked(e); // don't catch unchecked exceptions throw new ExceptionThrownUnchecked(e); } } diff --git a/src/test/java/org/cryptomator/cryptofs/CryptoFileSystemImplTest.java b/src/test/java/org/cryptomator/cryptofs/CryptoFileSystemImplTest.java index f67d7cbc..5ca1173c 100644 --- a/src/test/java/org/cryptomator/cryptofs/CryptoFileSystemImplTest.java +++ b/src/test/java/org/cryptomator/cryptofs/CryptoFileSystemImplTest.java @@ -714,8 +714,8 @@ public void copyDirectoryToAlreadyExistingDir() throws IOException { public class CreateDirectory { - private FileSystemProvider provider = mock(FileSystemProvider.class); - private CryptoFileSystemImpl fileSystem = mock(CryptoFileSystemImpl.class); + private final FileSystemProvider provider = mock(FileSystemProvider.class); + private final CryptoFileSystemImpl fileSystem = mock(CryptoFileSystemImpl.class); @Before public void setup() { @@ -796,37 +796,39 @@ public void createDirectoryCreatesDirectoryIfConditonsAreMet() throws IOExceptio } @Test - public void createDirectoryClearsDirIdAndDeletesDirFileIfWritingDirFileFails() throws IOException { + public void createDirectoryClearsDirIdAndDeletesDirFileIfCreatingDirFails() throws IOException { CryptoPath path = mock(CryptoPath.class); CryptoPath parent = mock(CryptoPath.class); - Path cyphertextParent = mock(Path.class); - Path cyphertextFile = mock(Path.class); - Path cyphertextDirFile = mock(Path.class); - Path cyphertextDirPath = mock(Path.class); + Path ciphertextParent = mock(Path.class, "ciphertextParent"); + Path ciphertextFile = mock(Path.class, "ciphertextFile"); + Path ciphertextDirFile = mock(Path.class, "ciphertextDirFile"); + Path ciphertextDirPath = mock(Path.class, "ciphertextDir"); String dirId = "DirId1234ABC"; FileChannelMock channel = new FileChannelMock(100); - Directory cyphertextDir = new Directory(dirId, cyphertextDirPath); + Directory ciphertextDir = new Directory(dirId, ciphertextDirPath); when(path.getParent()).thenReturn(parent); - when(cryptoPathMapper.getCiphertextDirPath(parent)).thenReturn(cyphertextParent); - when(cryptoPathMapper.getCiphertextFilePath(path, CiphertextFileType.FILE)).thenReturn(cyphertextFile); - when(cryptoPathMapper.getCiphertextFilePath(path, CiphertextFileType.DIRECTORY)).thenReturn(cyphertextDirFile); - when(cryptoPathMapper.getCiphertextDir(path)).thenReturn(cyphertextDir); - when(cyphertextParent.getFileSystem()).thenReturn(fileSystem); - when(cyphertextFile.getFileSystem()).thenReturn(fileSystem); - when(cyphertextDirFile.getFileSystem()).thenReturn(fileSystem); - when(cyphertextDirPath.getFileSystem()).thenReturn(fileSystem); - when(provider.newFileChannel(cyphertextDirFile, EnumSet.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE))).thenReturn(channel); - IOException expectedException = new IOException(); - channel.setFailOnNextOperation(expectedException); - doThrow(NoSuchFileException.class).when(provider).checkAccess(cyphertextFile); + when(cryptoPathMapper.getCiphertextDirPath(parent)).thenReturn(ciphertextParent); + when(cryptoPathMapper.getCiphertextFilePath(path, CiphertextFileType.FILE)).thenReturn(ciphertextFile); + when(cryptoPathMapper.getCiphertextFilePath(path, CiphertextFileType.DIRECTORY)).thenReturn(ciphertextDirFile); + when(cryptoPathMapper.getCiphertextDir(path)).thenReturn(ciphertextDir); + when(ciphertextParent.getFileSystem()).thenReturn(fileSystem); + when(ciphertextFile.getFileSystem()).thenReturn(fileSystem); + when(ciphertextDirFile.getFileSystem()).thenReturn(fileSystem); + when(ciphertextDirPath.getFileSystem()).thenReturn(fileSystem); + doThrow(new NoSuchFileException("ciphertextFile")).when(provider).checkAccess(ciphertextFile); + when(provider.newFileChannel(ciphertextDirFile, EnumSet.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE))).thenReturn(channel); - thrown.expect(is(expectedException)); + // make createDirectory with an FileSystemException during Files.createDirectories(ciphertextDirPath) + doThrow(new IOException()).when(provider).createDirectory(ciphertextDirPath); + when(ciphertextDirPath.toAbsolutePath()).thenReturn(ciphertextDirPath); + when(ciphertextDirPath.getParent()).thenReturn(null); + thrown.expect(IOException.class); try { inTest.createDirectory(path); } finally { - verify(provider).delete(cyphertextDirFile); - verify(dirIdProvider).delete(cyphertextDirFile); + verify(provider).delete(ciphertextDirFile); + verify(dirIdProvider).delete(ciphertextDirFile); } } @@ -834,8 +836,8 @@ public void createDirectoryClearsDirIdAndDeletesDirFileIfWritingDirFileFails() t public class IsHidden { - private FileSystemProvider provider = mock(FileSystemProvider.class); - private CryptoFileSystemImpl fileSystem = mock(CryptoFileSystemImpl.class); + private final FileSystemProvider provider = mock(FileSystemProvider.class); + private final CryptoFileSystemImpl fileSystem = mock(CryptoFileSystemImpl.class); @Before public void setup() { @@ -886,8 +888,8 @@ public void isHiddenReturnsFalseIfDosFileAttributeViewIsAvailableAndIsHiddenIsFa public class CheckAccess { - private FileSystemProvider provider = mock(FileSystemProvider.class); - private CryptoFileSystemImpl fileSystem = mock(CryptoFileSystemImpl.class); + private final FileSystemProvider provider = mock(FileSystemProvider.class); + private final CryptoFileSystemImpl fileSystem = mock(CryptoFileSystemImpl.class); @Before public void setup() { @@ -1110,8 +1112,8 @@ public void testAccessModeContainsOnlyKnownValues() { public class SetAttribute { - private FileSystemProvider provider = mock(FileSystemProvider.class); - private CryptoFileSystemImpl fileSystem = mock(CryptoFileSystemImpl.class); + private final FileSystemProvider provider = mock(FileSystemProvider.class); + private final CryptoFileSystemImpl fileSystem = mock(CryptoFileSystemImpl.class); @Before public void setup() { diff --git a/src/test/java/org/cryptomator/cryptofs/DirectoryIdLoaderTest.java b/src/test/java/org/cryptomator/cryptofs/DirectoryIdLoaderTest.java index 6828a33c..6e43e0f5 100644 --- a/src/test/java/org/cryptomator/cryptofs/DirectoryIdLoaderTest.java +++ b/src/test/java/org/cryptomator/cryptofs/DirectoryIdLoaderTest.java @@ -12,29 +12,32 @@ import static org.mockito.Mockito.when; import java.io.IOException; +import java.lang.reflect.Field; import java.nio.ByteBuffer; -import java.nio.channels.SeekableByteChannel; +import java.nio.channels.FileChannel; +import java.nio.channels.spi.AbstractInterruptibleChannel; import java.nio.file.FileSystem; +import java.nio.file.NoSuchFileException; import java.nio.file.Path; import java.nio.file.spi.FileSystemProvider; -import org.cryptomator.cryptofs.mocks.SeekableByteChannelMock; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; +import org.mockito.Mockito; public class DirectoryIdLoaderTest { @Rule public ExpectedException thrown = ExpectedException.none(); - private FileSystemProvider provider = mock(FileSystemProvider.class); - private FileSystem fileSystem = mock(FileSystem.class); - private Path dirFilePath = mock(Path.class); - private Path otherDirFilePath = mock(Path.class); + private final FileSystemProvider provider = mock(FileSystemProvider.class); + private final FileSystem fileSystem = mock(FileSystem.class); + private final Path dirFilePath = mock(Path.class); + private final Path otherDirFilePath = mock(Path.class); - private DirectoryIdLoader inTest = new DirectoryIdLoader(); + private final DirectoryIdLoader inTest = new DirectoryIdLoader(); @Before public void setup() { @@ -45,8 +48,8 @@ public void setup() { @Test public void testDirectoryIdsForTwoNonExistingFilesDiffer() throws IOException { - doThrow(new IOException()).when(provider).checkAccess(dirFilePath); - doThrow(new IOException()).when(provider).checkAccess(otherDirFilePath); + doThrow(new NoSuchFileException("foo")).when(provider).newFileChannel(eq(dirFilePath), any()); + doThrow(new NoSuchFileException("bar")).when(provider).newFileChannel(eq(otherDirFilePath), any()); String first = inTest.load(dirFilePath); String second = inTest.load(otherDirFilePath); @@ -56,7 +59,7 @@ public void testDirectoryIdsForTwoNonExistingFilesDiffer() throws IOException { @Test public void testDirectoryIdForNonExistingFileIsNotEmpty() throws IOException { - doThrow(new IOException()).when(provider).checkAccess(dirFilePath); + doThrow(new NoSuchFileException("foo")).when(provider).newFileChannel(eq(dirFilePath), any()); String result = inTest.load(dirFilePath); @@ -65,11 +68,17 @@ public void testDirectoryIdForNonExistingFileIsNotEmpty() throws IOException { } @Test - public void testDirectoryIdIsReadFromExistingFile() throws IOException { + public void testDirectoryIdIsReadFromExistingFile() throws IOException, ReflectiveOperationException { String expectedId = "asdüßT°z¬╚‗"; byte[] expectedIdBytes = expectedId.getBytes(UTF_8); - SeekableByteChannel channel = new SeekableByteChannelMock(ByteBuffer.wrap(expectedIdBytes)); - when(provider.newByteChannel(eq(dirFilePath), any())).thenReturn(channel); + FileChannel channel = createFileChannelMock(); + when(provider.newFileChannel(eq(dirFilePath), any())).thenReturn(channel); + when(channel.size()).thenReturn((long) expectedIdBytes.length); + when(channel.read(any(ByteBuffer.class))).then(invocation -> { + ByteBuffer buf = invocation.getArgument(0); + buf.put(expectedIdBytes); + return expectedIdBytes.length; + }); String result = inTest.load(dirFilePath); @@ -77,9 +86,10 @@ public void testDirectoryIdIsReadFromExistingFile() throws IOException { } @Test - public void testIOExceptionWhenExistingFileIsEmpty() throws IOException { - SeekableByteChannel channel = new SeekableByteChannelMock(ByteBuffer.allocate(0)); - when(provider.newByteChannel(eq(dirFilePath), any())).thenReturn(channel); + public void testIOExceptionWhenExistingFileIsEmpty() throws IOException, ReflectiveOperationException { + FileChannel channel = createFileChannelMock(); + when(provider.newFileChannel(eq(dirFilePath), any())).thenReturn(channel); + when(channel.size()).thenReturn(0l); thrown.expect(IOException.class); thrown.expectMessage("Invalid, empty directory file"); @@ -87,4 +97,27 @@ public void testIOExceptionWhenExistingFileIsEmpty() throws IOException { inTest.load(dirFilePath); } + @Test + public void testIOExceptionWhenExistingFileIsTooLarge() throws IOException, ReflectiveOperationException { + FileChannel channel = createFileChannelMock(); + when(provider.newFileChannel(eq(dirFilePath), any())).thenReturn(channel); + when(channel.size()).thenReturn((long) Integer.MAX_VALUE); + + thrown.expect(IOException.class); + thrown.expectMessage("Unexpectedly large directory file"); + + inTest.load(dirFilePath); + } + + private FileChannel createFileChannelMock() throws ReflectiveOperationException { + FileChannel channel = Mockito.mock(FileChannel.class); + Field channelOpenField = AbstractInterruptibleChannel.class.getDeclaredField("open"); + channelOpenField.setAccessible(true); + channelOpenField.set(channel, true); + Field channelCloseLockField = AbstractInterruptibleChannel.class.getDeclaredField("closeLock"); + channelCloseLockField.setAccessible(true); + channelCloseLockField.set(channel, new Object()); + return channel; + } + }