renamed module

main/frontend-webdav/src/test/java/org/cryptomator/filesystem/jackrabbit/FileSystemResourceLocatorFactoryTest.java

@@ -0,0 +1,61 @@
+package org.cryptomator.filesystem.jackrabbit;
+
+import java.net.URI;
+import java.nio.ByteBuffer;
+
+import org.cryptomator.filesystem.FileSystem;
+import org.cryptomator.filesystem.WritableFile;
+import org.cryptomator.filesystem.inmem.InMemoryFileSystem;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class FileSystemResourceLocatorFactoryTest {
+
+	private FileSystemResourceLocatorFactory factory;
+
+	@Before
+	public void setupLocatorFactory() {
+		final FileSystem fs = new InMemoryFileSystem();
+		fs.folder("existingFolder").create();
+		try (WritableFile writable = fs.file("existingFile").openWritable()) {
+			writable.write(ByteBuffer.allocate(0));
+		}
+		factory = new FileSystemResourceLocatorFactory(URI.create("http://localhost/contextroot"), fs);
+	}
+
+	@Test
+	public void testCreateFolders() {
+		FileSystemResourceLocator locator = factory.createResourceLocator(null, null, "/foo/bar/");
+		Assert.assertTrue(locator instanceof FolderLocator);
+		Assert.assertEquals("bar", locator.name());
+		Assert.assertEquals("foo", locator.parent().get().name());
+		Assert.assertEquals("", locator.parent().get().parent().get().name());
+		Assert.assertFalse(locator.parent().get().parent().get().parent().isPresent());
+
+		locator = factory.createResourceLocator("http://localhost/contextroot", "http://localhost/contextroot/foo/bar/");
+		Assert.assertTrue(locator instanceof FolderLocator);
+		Assert.assertEquals("bar", locator.name());
+		Assert.assertEquals("foo", locator.parent().get().name());
+		Assert.assertEquals("", locator.parent().get().parent().get().name());
+		Assert.assertFalse(locator.parent().get().parent().get().parent().isPresent());
+	}
+
+	@Test
+	public void testCreateFiles() {
+		FileSystemResourceLocator locator = factory.createResourceLocator(null, null, "/foo/bar");
+		Assert.assertTrue(locator instanceof FileLocator);
+		Assert.assertEquals("bar", locator.name());
+		Assert.assertEquals("foo", locator.parent().get().name());
+		Assert.assertEquals("", locator.parent().get().parent().get().name());
+		Assert.assertFalse(locator.parent().get().parent().get().parent().isPresent());
+
+		locator = factory.createResourceLocator("http://localhost/contextroot", "http://localhost/contextroot/foo/bar");
+		Assert.assertTrue(locator instanceof FileLocator);
+		Assert.assertEquals("bar", locator.name());
+		Assert.assertEquals("foo", locator.parent().get().name());
+		Assert.assertEquals("", locator.parent().get().parent().get().name());
+		Assert.assertFalse(locator.parent().get().parent().get().parent().isPresent());
+	}
+
+}

main/frontend-webdav/src/test/java/org/cryptomator/webdav/filters/LoggingHttpFilter.java

@@ -0,0 +1,174 @@
+package org.cryptomator.webdav.filters;
+
+import static java.lang.String.format;
+import static java.util.Arrays.asList;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+
+import javax.servlet.FilterChain;
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class LoggingHttpFilter implements HttpFilter {
+
+	private static final Set<String> METHODS_TO_LOG_DETAILED = methodsToLog();
+
+	private static final Set<String> methodsToLog() {
+		String methodsToLog = System.getProperty("cryptomator.LoggingHttpFilter.methodsToLogDetailed");
+		if (methodsToLog == null) {
+			return Collections.emptySet();
+		} else {
+			return new HashSet<>(asList(methodsToLog.toUpperCase().split(",")));
+		}
+	}
+
+	private final Logger LOG = LoggerFactory.getLogger(LoggingHttpFilter.class);
+
+	@Override
+	public void doFilterHttp(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
+		if (METHODS_TO_LOG_DETAILED.contains(request.getMethod().toUpperCase())) {
+			logDetailed(request, response, chain);
+		} else {
+			logBasic(request, response, chain);
+		}
+	}
+
+	private void logBasic(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
+		Optional<Throwable> thrown = Optional.empty();
+		try {
+			chain.doFilter(request, response);
+		} catch (IOException | ServletException e) {
+			thrown = Optional.of(e);
+			throw e;
+		} catch (RuntimeException | Error e) {
+			thrown = Optional.of(e);
+			throw e;
+		} finally {
+			if (thrown.isPresent()) {
+				logError(request, thrown.get());
+			} else {
+				logSuccess(request, response);
+			}
+		}
+	}
+
+	private void logDetailed(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
+		RecordingHttpServletRequest recordingRequest = new RecordingHttpServletRequest(request);
+		RecordingHttpServletResponse recordingResponse = new RecordingHttpServletResponse(response);
+		Optional<Throwable> thrown = Optional.empty();
+		try {
+			chain.doFilter(recordingRequest, recordingResponse);
+		} catch (IOException | ServletException e) {
+			thrown = Optional.of(e);
+			throw e;
+		} catch (RuntimeException | Error e) {
+			thrown = Optional.of(e);
+			throw e;
+		} finally {
+			if (thrown.isPresent()) {
+				logError(recordingRequest, thrown.get());
+			} else {
+				logSuccess(recordingRequest, recordingResponse);
+			}
+		}
+	}
+
+	private void logSuccess(HttpServletRequest request, HttpServletResponse response) {
+		LOG.debug(format(
+				"## Request ##\n" + //
+						"%s %s %s\n" //
+						+ "%s\n" //
+						+ "## Response ##\n" //
+						+ "%s %s\n" //
+						+ "%s\n", //
+				request.getMethod(), request.getRequestURI(), request.getProtocol(), //
+				headers(request), //
+				request.getProtocol(), response.getStatus(), //
+				headers(response)));
+	}
+
+	private void logError(HttpServletRequest request, Throwable throwable) {
+		LOG.error(
+				format("## Request ##\n" + //
+						"%s %s %s\n" //
+						+ "%s\n" //
+						+ "%s\n\n", //
+				request.getMethod(), request.getRequestURI(), request.getProtocol(), //
+				headers(request)), //
+				throwable);
+	}
+
+	private void logSuccess(RecordingHttpServletRequest request, RecordingHttpServletResponse response) {
+		LOG.debug(format(
+				"## Request ##\n" + //
+						"%s %s %s\n" //
+						+ "%s\n" //
+						+ "%s\n\n" //
+						+ "## Response ##\n" //
+						+ "%s %s\n" //
+						+ "%s\n" //
+						+ "%s", //
+				request.getMethod(), request.getRequestURI(), request.getProtocol(), //
+				headers(request), //
+				new String(request.getRecording()), //
+				request.getProtocol(), response.getStatus(), //
+				headers(response), //
+				new String(response.getRecording())));
+	}
+
+	private void logError(RecordingHttpServletRequest request, Throwable throwable) {
+		LOG.error(
+				format("## Request ##\n" + //
+						"%s %s %s\n" //
+						+ "%s\n" //
+						+ "%s\n\n", //
+				request.getMethod(), request.getRequestURI(), request.getProtocol(), //
+				headers(request), //
+				new String(request.getRecording())), //
+				throwable);
+	}
+
+	private String headers(HttpServletResponse response) {
+		StringBuilder result = new StringBuilder();
+		for (String headerName : response.getHeaderNames()) {
+			for (String value : response.getHeaders(headerName)) {
+				result.append(headerName).append(": ").append(value).append('\n');
+			}
+		}
+		return result.toString();
+	}
+
+	private String headers(HttpServletRequest request) {
+		StringBuilder result = new StringBuilder();
+		Enumeration<String> headerNames = request.getHeaderNames();
+		while (headerNames.hasMoreElements()) {
+			String headerName = headerNames.nextElement();
+			Enumeration<String> values = request.getHeaders(headerName);
+			while (values.hasMoreElements()) {
+				result.append(headerName).append(": ").append(values.nextElement()).append('\n');
+			}
+		}
+		return result.toString();
+	}
+
+	@Override
+	public void init(FilterConfig filterConfig) throws ServletException {
+		// empty
+	}
+
+	@Override
+	public void destroy() {
+		// empty
+	}
+
+}

main/frontend-webdav/src/test/java/org/cryptomator/webdav/filters/MacChunkedPutCompatibilityFilterTest.java

@@ -0,0 +1,122 @@
+package org.cryptomator.webdav.filters;
+
+import java.io.IOException;
+
+import javax.servlet.FilterChain;
+import javax.servlet.ServletException;
+import javax.servlet.ServletInputStream;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+
+public class MacChunkedPutCompatibilityFilterTest {
+
+	private MacChunkedPutCompatibilityFilter filter;
+	private FilterChain chain;
+	private HttpServletRequest request;
+	private HttpServletResponse response;
+
+	@Before
+	public void setup() {
+		filter = new MacChunkedPutCompatibilityFilter();
+		chain = Mockito.mock(FilterChain.class);
+		request = Mockito.mock(HttpServletRequest.class);
+		response = Mockito.mock(HttpServletResponse.class);
+	}
+
+	@Test
+	public void testUnfilteredGetRequest() throws IOException, ServletException {
+		Mockito.when(request.getMethod()).thenReturn("GET");
+		filter.doFilter(request, response, chain);
+
+		ArgumentCaptor<HttpServletRequest> wrappedReq = ArgumentCaptor.forClass(HttpServletRequest.class);
+		Mockito.verify(chain).doFilter(wrappedReq.capture(), Mockito.any(ServletResponse.class));
+		Assert.assertSame(request, wrappedReq.getValue());
+	}
+
+	@Test
+	public void testUnfilteredPutRequest1() throws IOException, ServletException {
+		Mockito.when(request.getMethod()).thenReturn("PUT");
+		Mockito.when(request.getHeader("Transfer-Encoding")).thenReturn(null);
+		filter.doFilter(request, response, chain);
+
+		ArgumentCaptor<HttpServletRequest> wrappedReq = ArgumentCaptor.forClass(HttpServletRequest.class);
+		Mockito.verify(chain).doFilter(wrappedReq.capture(), Mockito.any(ServletResponse.class));
+		Assert.assertSame(request, wrappedReq.getValue());
+	}
+
+	@Test
+	public void testUnfilteredPutRequest2() throws IOException, ServletException {
+		Mockito.when(request.getMethod()).thenReturn("PUT");
+		Mockito.when(request.getHeader("Transfer-Encoding")).thenReturn("chunked");
+		Mockito.when(request.getHeader("X-Expected-Entity-Length")).thenReturn(null);
+		filter.doFilter(request, response, chain);
+
+		ArgumentCaptor<HttpServletRequest> wrappedReq = ArgumentCaptor.forClass(HttpServletRequest.class);
+		Mockito.verify(chain).doFilter(wrappedReq.capture(), Mockito.any(ServletResponse.class));
+		Assert.assertSame(request, wrappedReq.getValue());
+	}
+
+	@Test
+	public void testMalformedXExpectedEntityLengthHeader() throws IOException, ServletException {
+		Mockito.when(request.getMethod()).thenReturn("PUT");
+		Mockito.when(request.getHeader("Transfer-Encoding")).thenReturn("chunked");
+		Mockito.when(request.getHeader("X-Expected-Entity-Length")).thenReturn("NaN");
+		filter.doFilter(request, response, chain);
+
+		Mockito.verify(response).sendError(Mockito.eq(HttpServletResponse.SC_BAD_REQUEST), Mockito.anyString());
+		Mockito.verifyNoMoreInteractions(chain);
+	}
+
+	/* actual input stream testing */
+
+	@Test
+	public void testBoundedInputStream() throws IOException, ServletException {
+		ServletInputStream in = Mockito.mock(ServletInputStream.class);
+
+		Mockito.when(request.getMethod()).thenReturn("PUT");
+		Mockito.when(request.getHeader("Transfer-Encoding")).thenReturn("chunked");
+		Mockito.when(request.getHeader("X-Expected-Entity-Length")).thenReturn("5");
+		Mockito.when(request.getInputStream()).thenReturn(in);
+		filter.doFilter(request, response, chain);
+
+		ArgumentCaptor<HttpServletRequest> wrappedReq = ArgumentCaptor.forClass(HttpServletRequest.class);
+		Mockito.verify(chain).doFilter(wrappedReq.capture(), Mockito.any(ServletResponse.class));
+		ServletInputStream wrappedIn = wrappedReq.getValue().getInputStream();
+
+		Mockito.when(in.isFinished()).thenReturn(false);
+		Assert.assertFalse(wrappedIn.isFinished());
+
+		Mockito.when(in.isReady()).thenReturn(true);
+		Assert.assertTrue(wrappedIn.isReady());
+
+		Mockito.when(in.read()).thenReturn(0xFF);
+		Assert.assertEquals(0xFF, wrappedIn.read());
+
+		Mockito.when(in.available()).thenReturn(100);
+		Assert.assertEquals(100, wrappedIn.available());
+
+		Mockito.when(in.skip(2)).thenReturn(2l);
+		Assert.assertEquals(2, wrappedIn.skip(2));
+
+		Mockito.when(in.read(Mockito.any(), Mockito.eq(0), Mockito.eq(100))).thenReturn(100);
+		Mockito.when(in.read(Mockito.any(), Mockito.eq(0), Mockito.eq(2))).thenReturn(2);
+		Assert.assertEquals(2, wrappedIn.read(new byte[100], 0, 100));
+
+		Mockito.when(in.read()).thenReturn(0xFF);
+		Assert.assertEquals(-1, wrappedIn.read());
+
+		Mockito.when(in.isFinished()).thenReturn(false);
+		Assert.assertTrue(wrappedIn.isFinished());
+
+		Mockito.when(in.isReady()).thenReturn(true);
+		Assert.assertFalse(wrappedIn.isReady());
+	}
+
+}

main/frontend-webdav/src/test/java/org/cryptomator/webdav/filters/RecordingHttpServletRequest.java

@@ -0,0 +1,27 @@
+package org.cryptomator.webdav.filters;
+
+import java.io.IOException;
+
+import javax.servlet.ServletInputStream;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletRequestWrapper;
+
+class RecordingHttpServletRequest extends HttpServletRequestWrapper {
+
+	private final RecordingServletInputStream recording;
+
+	public RecordingHttpServletRequest(HttpServletRequest request) throws IOException {
+		super(request);
+		recording = new RecordingServletInputStream(request.getInputStream());
+	}
+
+	@Override
+	public ServletInputStream getInputStream() throws IOException {
+		return recording;
+	}
+
+	public byte[] getRecording() {
+		return recording.getRecording();
+	}
+
+}

main/frontend-webdav/src/test/java/org/cryptomator/webdav/filters/RecordingHttpServletResponse.java

@@ -0,0 +1,27 @@
+package org.cryptomator.webdav.filters;
+
+import java.io.IOException;
+
+import javax.servlet.ServletOutputStream;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpServletResponseWrapper;
+
+class RecordingHttpServletResponse extends HttpServletResponseWrapper {
+
+	private final RecordingServletOutputStream recording;
+
+	public RecordingHttpServletResponse(HttpServletResponse response) throws IOException {
+		super(response);
+		recording = new RecordingServletOutputStream(response.getOutputStream());
+	}
+
+	@Override
+	public ServletOutputStream getOutputStream() throws IOException {
+		return recording;
+	}
+
+	public byte[] getRecording() {
+		return recording.getRecording();
+	}
+
+}

main/frontend-webdav/src/test/java/org/cryptomator/webdav/filters/RecordingServletInputStream.java

@@ -0,0 +1,73 @@
+package org.cryptomator.webdav.filters;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import javax.servlet.ReadListener;
+import javax.servlet.ServletInputStream;
+
+import org.apache.commons.io.input.TeeInputStream;
+
+class RecordingServletInputStream extends ServletInputStream {
+
+	private final ServletInputStream delegate;
+	private final TeeInputStream teeInputStream;
+	private final ByteArrayOutputStream recording = new ByteArrayOutputStream(4096);
+
+	public RecordingServletInputStream(ServletInputStream delegate) {
+		this.delegate = delegate;
+		this.teeInputStream = new TeeInputStream(delegate, recording);
+	}
+
+	public int read() throws IOException {
+		return teeInputStream.read();
+	}
+
+	public int read(byte[] b) throws IOException {
+		return teeInputStream.read(b);
+	}
+
+	public int read(byte[] b, int off, int len) throws IOException {
+		return teeInputStream.read(b, off, len);
+	}
+
+	public boolean isFinished() {
+		return delegate.isFinished();
+	}
+
+	public boolean isReady() {
+		return delegate.isReady();
+	}
+
+	public void setReadListener(ReadListener readListener) {
+		delegate.setReadListener(readListener);
+	}
+
+	public long skip(long n) throws IOException {
+		return teeInputStream.skip(n);
+	}
+
+	public int available() throws IOException {
+		return teeInputStream.available();
+	}
+
+	public void close() throws IOException {
+		teeInputStream.close();
+	}
+
+	public byte[] getRecording() {
+		return recording.toByteArray();
+	}
+
+	public void mark(int readlimit) {
+	}
+
+	public void reset() throws IOException {
+		throw new IOException("Mark not supported");
+	}
+
+	public boolean markSupported() {
+		return false;
+	}
+
+}

main/frontend-webdav/src/test/java/org/cryptomator/webdav/filters/RecordingServletOutputStream.java

@@ -0,0 +1,54 @@
+package org.cryptomator.webdav.filters;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import javax.servlet.ServletOutputStream;
+import javax.servlet.WriteListener;
+
+import org.apache.commons.io.output.TeeOutputStream;
+
+class RecordingServletOutputStream extends ServletOutputStream {
+
+	private final ServletOutputStream delegate;
+	private final TeeOutputStream teeOutputStream;
+	private final ByteArrayOutputStream recording = new ByteArrayOutputStream(4096);
+
+	public RecordingServletOutputStream(ServletOutputStream delegate) {
+		this.delegate = delegate;
+		this.teeOutputStream = new TeeOutputStream(delegate, recording);
+	}
+
+	public void write(int b) throws IOException {
+		teeOutputStream.write(b);
+	}
+
+	public void write(byte[] b) throws IOException {
+		teeOutputStream.write(b);
+	}
+
+	public void write(byte[] b, int off, int len) throws IOException {
+		teeOutputStream.write(b, off, len);
+	}
+
+	public void flush() throws IOException {
+		teeOutputStream.flush();
+	}
+
+	public void close() throws IOException {
+		teeOutputStream.close();
+	}
+
+	public boolean isReady() {
+		return delegate.isReady();
+	}
+
+	public void setWriteListener(WriteListener writeListener) {
+		delegate.setWriteListener(writeListener);
+	}
+
+	public byte[] getRecording() {
+		return recording.toByteArray();
+	}
+
+}

main/frontend-webdav/src/test/java/org/cryptomator/webdav/filters/UriNormalizationFilterTest.java

@@ -0,0 +1,162 @@
+package org.cryptomator.webdav.filters;
+
+import java.io.IOException;
+
+import javax.servlet.FilterChain;
+import javax.servlet.ServletException;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.cryptomator.webdav.filters.UriNormalizationFilter.ResourceTypeChecker;
+import org.cryptomator.webdav.filters.UriNormalizationFilter.ResourceTypeChecker.ResourceType;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+
+public class UriNormalizationFilterTest {
+
+	private ResourceTypeChecker resourceTypeChecker;
+	private UriNormalizationFilter filter;
+	private FilterChain chain;
+	private HttpServletRequest request;
+	private HttpServletResponse response;
+
+	@Before
+	public void setup() {
+		resourceTypeChecker = Mockito.mock(ResourceTypeChecker.class);
+		filter = new UriNormalizationFilter(resourceTypeChecker);
+		chain = Mockito.mock(FilterChain.class);
+		request = Mockito.mock(HttpServletRequest.class);
+		response = Mockito.mock(HttpServletResponse.class);
+
+		Mockito.when(resourceTypeChecker.typeOfResource("/file")).thenReturn(ResourceType.FILE);
+		Mockito.when(resourceTypeChecker.typeOfResource("/file/")).thenReturn(ResourceType.FILE);
+		Mockito.when(resourceTypeChecker.typeOfResource("/folder")).thenReturn(ResourceType.FOLDER);
+		Mockito.when(resourceTypeChecker.typeOfResource("/folder/")).thenReturn(ResourceType.FOLDER);
+		Mockito.when(resourceTypeChecker.typeOfResource("/404")).thenReturn(ResourceType.UNKNOWN);
+		Mockito.when(resourceTypeChecker.typeOfResource("/404/")).thenReturn(ResourceType.UNKNOWN);
+	}
+
+	/* FILE */
+
+	@Test
+	public void testFileRequest1() throws IOException, ServletException {
+		Mockito.when(request.getPathInfo()).thenReturn("/file");
+		Mockito.when(request.getRequestURI()).thenReturn("/file");
+		filter.doFilter(request, response, chain);
+		Mockito.verify(resourceTypeChecker).typeOfResource("/file");
+
+		ArgumentCaptor<HttpServletRequest> wrappedReq = ArgumentCaptor.forClass(HttpServletRequest.class);
+		Mockito.verify(chain).doFilter(wrappedReq.capture(), Mockito.any(ServletResponse.class));
+		Assert.assertEquals("/file", wrappedReq.getValue().getRequestURI());
+	}
+
+	@Test
+	public void testFileRequest2() throws IOException, ServletException {
+		Mockito.when(request.getPathInfo()).thenReturn("/file/");
+		Mockito.when(request.getRequestURI()).thenReturn("/file/");
+		filter.doFilter(request, response, chain);
+		Mockito.verify(resourceTypeChecker).typeOfResource("/file/");
+
+		ArgumentCaptor<HttpServletRequest> wrappedReq = ArgumentCaptor.forClass(HttpServletRequest.class);
+		Mockito.verify(chain).doFilter(wrappedReq.capture(), Mockito.any(ServletResponse.class));
+		Assert.assertEquals("/file", wrappedReq.getValue().getRequestURI());
+	}
+
+	@Test
+	public void testCopyFileRequest() throws IOException, ServletException {
+		Mockito.when(request.getPathInfo()).thenReturn("/file/");
+		Mockito.when(request.getRequestURI()).thenReturn("/file/");
+		Mockito.when(request.getMethod()).thenReturn("COPY");
+		Mockito.when(request.getHeader("Destination")).thenReturn("/404/");
+		filter.doFilter(request, response, chain);
+
+		ArgumentCaptor<HttpServletRequest> wrappedReq = ArgumentCaptor.forClass(HttpServletRequest.class);
+		Mockito.verify(chain).doFilter(wrappedReq.capture(), Mockito.any(ServletResponse.class));
+		Assert.assertEquals("/404", wrappedReq.getValue().getHeader("Destination"));
+	}
+
+	/* FOLDER */
+
+	@Test
+	public void testFolderRequest1() throws IOException, ServletException {
+		Mockito.when(request.getPathInfo()).thenReturn("/folder");
+		Mockito.when(request.getRequestURI()).thenReturn("/folder");
+		filter.doFilter(request, response, chain);
+		Mockito.verify(resourceTypeChecker).typeOfResource("/folder");
+
+		ArgumentCaptor<HttpServletRequest> wrappedReq = ArgumentCaptor.forClass(HttpServletRequest.class);
+		Mockito.verify(chain).doFilter(wrappedReq.capture(), Mockito.any(ServletResponse.class));
+		Assert.assertEquals("/folder/", wrappedReq.getValue().getRequestURI());
+	}
+
+	@Test
+	public void testFolderRequest2() throws IOException, ServletException {
+		Mockito.when(request.getPathInfo()).thenReturn("/folder/");
+		Mockito.when(request.getRequestURI()).thenReturn("/folder/");
+		filter.doFilter(request, response, chain);
+		Mockito.verify(resourceTypeChecker).typeOfResource("/folder/");
+
+		ArgumentCaptor<HttpServletRequest> wrappedReq = ArgumentCaptor.forClass(HttpServletRequest.class);
+		Mockito.verify(chain).doFilter(wrappedReq.capture(), Mockito.any(ServletResponse.class));
+		Assert.assertEquals("/folder/", wrappedReq.getValue().getRequestURI());
+	}
+
+	@Test
+	public void testMoveFolderRequest() throws IOException, ServletException {
+		Mockito.when(request.getPathInfo()).thenReturn("/folder");
+		Mockito.when(request.getRequestURI()).thenReturn("/folder");
+		Mockito.when(request.getMethod()).thenReturn("MOVE");
+		Mockito.when(request.getHeader("Destination")).thenReturn("/404");
+		filter.doFilter(request, response, chain);
+
+		ArgumentCaptor<HttpServletRequest> wrappedReq = ArgumentCaptor.forClass(HttpServletRequest.class);
+		Mockito.verify(chain).doFilter(wrappedReq.capture(), Mockito.any(ServletResponse.class));
+		Assert.assertEquals("/404/", wrappedReq.getValue().getHeader("Destination"));
+	}
+
+	/* UNKNOWN */
+
+	@Test
+	public void testUnknownPutRequest() throws IOException, ServletException {
+		Mockito.when(request.getPathInfo()).thenReturn("/404/");
+		Mockito.when(request.getRequestURI()).thenReturn("/404/");
+		Mockito.when(request.getMethod()).thenReturn("PUT");
+		filter.doFilter(request, response, chain);
+		Mockito.verify(resourceTypeChecker).typeOfResource("/404/");
+
+		ArgumentCaptor<HttpServletRequest> wrappedReq = ArgumentCaptor.forClass(HttpServletRequest.class);
+		Mockito.verify(chain).doFilter(wrappedReq.capture(), Mockito.any(ServletResponse.class));
+		Assert.assertEquals("/404", wrappedReq.getValue().getRequestURI());
+	}
+
+	@Test
+	public void testUnknownMkcolRequest() throws IOException, ServletException {
+		Mockito.when(request.getPathInfo()).thenReturn("/404");
+		Mockito.when(request.getRequestURI()).thenReturn("/404");
+		Mockito.when(request.getMethod()).thenReturn("MKCOL");
+		filter.doFilter(request, response, chain);
+		Mockito.verify(resourceTypeChecker).typeOfResource("/404");
+
+		ArgumentCaptor<HttpServletRequest> wrappedReq = ArgumentCaptor.forClass(HttpServletRequest.class);
+		Mockito.verify(chain).doFilter(wrappedReq.capture(), Mockito.any(ServletResponse.class));
+		Assert.assertEquals("/404/", wrappedReq.getValue().getRequestURI());
+	}
+
+	@Test
+	public void testUnknownPropfindRequest() throws IOException, ServletException {
+		Mockito.when(request.getPathInfo()).thenReturn("/404");
+		Mockito.when(request.getRequestURI()).thenReturn("/404");
+		Mockito.when(request.getMethod()).thenReturn("PROPFIND");
+		filter.doFilter(request, response, chain);
+		Mockito.verify(resourceTypeChecker).typeOfResource("/404");
+
+		ArgumentCaptor<HttpServletRequest> wrappedReq = ArgumentCaptor.forClass(HttpServletRequest.class);
+		Mockito.verify(chain).doFilter(wrappedReq.capture(), Mockito.any(ServletResponse.class));
+		Assert.assertSame(request, wrappedReq.getValue());
+	}
+
+}

main/frontend-webdav/src/test/java/org/cryptomator/webdav/jackrabbitservlet/FileSystemBasedWebDavServer.java

@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * Copyright (c) 2015 Sebastian Stenzel and others.
+ * This file is licensed under the terms of the MIT license.
+ * See the LICENSE.txt file for more info.
+ *
+ * Contributors:
+ *     Sebastian Stenzel - initial API and implementation
+ *******************************************************************************/
+package org.cryptomator.webdav.jackrabbitservlet;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+import org.cryptomator.filesystem.FileSystem;
+import org.eclipse.jetty.server.Connector;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.ServerConnector;
+import org.eclipse.jetty.server.handler.ContextHandlerCollection;
+import org.eclipse.jetty.util.thread.QueuedThreadPool;
+import org.eclipse.jetty.util.thread.ThreadPool;
+
+class FileSystemBasedWebDavServer {
+
+	private final Server server;
+	private final ServerConnector localConnector;
+	private final ContextHandlerCollection servletCollection;
+
+	public FileSystemBasedWebDavServer(FileSystem fileSystem) {
+		final BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>(10);
+		final ThreadPool tp = new QueuedThreadPool(4, 1, 1, queue);
+		server = new Server(tp);
+		localConnector = new ServerConnector(server);
+		localConnector.setHost("localhost");
+		localConnector.setPort(8080);
+		servletCollection = new ContextHandlerCollection();
+
+		final URI servletContextRoot1;
+		final URI servletContextRoot2;
+		try {
+			servletContextRoot1 = new URI("http", null, "localhost", 8080, "/foo/", null, null);
+			servletContextRoot2 = new URI("http", null, "localhost", 8080, "/bar/", null, null);
+		} catch (URISyntaxException e) {
+			throw new IllegalStateException(e);
+		}
+
+		final WebDavServletContextFactory servletContextFactory = new WebDavServletContextFactory();
+		servletCollection.addHandler(servletContextFactory.create(servletContextRoot1, fileSystem));
+		servletCollection.addHandler(servletContextFactory.create(servletContextRoot2, fileSystem));
+		servletCollection.mapContexts();
+
+		server.setConnectors(new Connector[] {localConnector});
+		server.setHandler(servletCollection);
+	}
+
+	public void start() throws Exception {
+		server.start();
+	}
+
+	public void stop() throws Exception {
+		server.stop();
+	}
+
+}

main/frontend-webdav/src/test/java/org/cryptomator/webdav/jackrabbitservlet/InMemoryWebDavServer.java

@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * Copyright (c) 2015 Sebastian Stenzel and others.
+ * This file is licensed under the terms of the MIT license.
+ * See the LICENSE.txt file for more info.
+ *
+ * Contributors:
+ *     Sebastian Stenzel - initial API and implementation
+ *******************************************************************************/
+package org.cryptomator.webdav.jackrabbitservlet;
+
+import java.nio.ByteBuffer;
+
+import org.cryptomator.filesystem.FileSystem;
+import org.cryptomator.filesystem.WritableFile;
+import org.cryptomator.filesystem.inmem.InMemoryFileSystem;
+
+public class InMemoryWebDavServer {
+
+	public static void main(String[] args) throws Exception {
+		FileSystem fileSystem = setupFilesystem();
+		FileSystemBasedWebDavServer server = new FileSystemBasedWebDavServer(fileSystem);
+
+		server.start();
+		System.out.println("Server started. Press any key to stop it...");
+		System.in.read();
+		server.stop();
+	}
+
+	private static FileSystem setupFilesystem() {
+		FileSystem fileSystem = new InMemoryFileSystem();
+		fileSystem.folder("mamals").folder("cats").create();
+		fileSystem.folder("mamals").folder("dogs").create();
+		try (WritableFile writable = fileSystem.folder("mamals").folder("cats").file("Garfield.txt").openWritable()) {
+			writable.write(ByteBuffer.wrap("meow".getBytes()));
+		}
+		return fileSystem;
+	}
+
+}

main/frontend-webdav/src/test/java/org/cryptomator/webdav/jackrabbitservlet/NioWebDavServer.java

@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * Copyright (c) 2015 Sebastian Stenzel and others.
+ * This file is licensed under the terms of the MIT license.
+ * See the LICENSE.txt file for more info.
+ *
+ * Contributors:
+ *     Sebastian Stenzel - initial API and implementation
+ *******************************************************************************/
+package org.cryptomator.webdav.jackrabbitservlet;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.UncheckedIOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Optional;
+
+import org.cryptomator.filesystem.FileSystem;
+import org.cryptomator.filesystem.nio.NioFileSystem;
+
+public class NioWebDavServer {
+
+	private static final String PATH_TO_SERVE_PROPERTY = "pathToServe";
+
+	public static void main(String[] args) throws Exception {
+		FileSystem fileSystem = setupFilesystem();
+		FileSystemBasedWebDavServer server = new FileSystemBasedWebDavServer(fileSystem);
+
+		server.start();
+		System.out.println("Server started. Press any key to stop it...");
+		System.in.read();
+		server.stop();
+	}
+
+	private static FileSystem setupFilesystem() {
+		return NioFileSystem.rootedAt(pathToServe());
+	}
+
+	private static Path pathToServe() {
+		Path path = pathFromSystemProperty().orElseGet(NioWebDavServer::pathEnteredByUser);
+		if (!Files.isDirectory(path)) {
+			throw new RuntimeException("Path is not a directory");
+		}
+		System.out.println("Serving " + path);
+		return path;
+	}
+
+	private static Optional<Path> pathFromSystemProperty() {
+		String value = System.getProperty(PATH_TO_SERVE_PROPERTY);
+		if (value == null) {
+			return Optional.empty();
+		} else {
+			return Optional.of(Paths.get(value));
+		}
+	}
+
+	private static Path pathEnteredByUser() {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in, Charset.defaultCharset()));
+		System.out.print("Enter absolute path to serve (must be an existing directory): ");
+		try {
+			return Paths.get(in.readLine());
+		} catch (IOException e) {
+			throw new UncheckedIOException(e);
+		}
+	}
+
+}

main/frontend-webdav/src/test/resources/log4j2.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!--
+  Copyright (c) 2014 Markus Kreusch
+  This file is licensed under the terms of the MIT license.
+  See the LICENSE.txt file for more info.
+  
+  Contributors:
+      Sebastian Stenzel - log4j config for WebDAV unit tests
+-->
+<Configuration status="WARN">
+
+	<Appenders>
+		<Console name="Console" target="SYSTEM_OUT">
+			<PatternLayout pattern="%16d %-5p [%c{1}:%L] %m%n" />
+			<ThresholdFilter level="WARN" onMatch="DENY" onMismatch="ACCEPT" />
+		</Console>
+		<Console name="StdErr" target="SYSTEM_ERR">
+			<PatternLayout pattern="%16d %-5p [%c{1}:%L] %m%n" />
+			<ThresholdFilter level="WARN" onMatch="ACCEPT" onMismatch="DENY" />
+		</Console>
+	</Appenders>
+
+	<Loggers>
+		<!-- show our own debug messages: -->
+		<Logger name="org.cryptomator" level="DEBUG" />
+		<!-- mute dependencies: -->
+		<Root level="INFO">
+			<AppenderRef ref="Console" />
+			<AppenderRef ref="StdErr" />
+		</Root>
+	</Loggers>
+
+</Configuration>