14 files changed, 712 insertions, 88 deletions
diff --git a/tests/lib/files/cache/cache.php b/tests/lib/files/cache/cache.php
index 250842805e5..527c1d1b2a1 100644
--- a/tests/lib/files/cache/cache.php
+++ b/tests/lib/files/cache/cache.php
@@ -8,6 +8,8 @@
 
 namespace Test\Files\Cache;
 
+use PHPUnit_Framework_MockObject_MockObject;
+
 class LongId extends \OC\Files\Storage\Temporary {
 	public function getId() {
 		return 'long:' . str_repeat('foo', 50) . parent::getId();
@@ -19,11 +21,19 @@ class Cache extends \PHPUnit_Framework_TestCase {
 	 * @var \OC\Files\Storage\Temporary $storage;
 	 */
 	private $storage;
+	/**
+	 * @var \OC\Files\Storage\Temporary $storage2;
+	 */
+	private $storage2;
 
 	/**
 	 * @var \OC\Files\Cache\Cache $cache
 	 */
 	private $cache;
+	/**
+	 * @var \OC\Files\Cache\Cache $cache2
+	 */
+	private $cache2;
 
 	public function testSimple() {
 		$file1 = 'foo';
@@ -162,13 +172,21 @@ class Cache extends \PHPUnit_Framework_TestCase {
 		$file4 = 'folder/foo/1';
 		$file5 = 'folder/foo/2';
 		$data = array('size' => 100, 'mtime' => 50, 'mimetype' => 'foo/bar');
+		$folderData = array('size' => 100, 'mtime' => 50, 'mimetype' => 'httpd/unix-directory');
 
-		$this->cache->put($file1, $data);
-		$this->cache->put($file2, $data);
-		$this->cache->put($file3, $data);
+		$this->cache->put($file1, $folderData);
+		$this->cache->put($file2, $folderData);
+		$this->cache->put($file3, $folderData);
 		$this->cache->put($file4, $data);
 		$this->cache->put($file5, $data);
 
+		/* simulate a second user with a different storage id but the same folder structure */
+		$this->cache2->put($file1, $folderData);
+		$this->cache2->put($file2, $folderData);
+		$this->cache2->put($file3, $folderData);
+		$this->cache2->put($file4, $data);
+		$this->cache2->put($file5, $data);
+
 		$this->cache->move('folder/foo', 'folder/foobar');
 
 		$this->assertFalse($this->cache->inCache('folder/foo'));
@@ -179,6 +197,16 @@ class Cache extends \PHPUnit_Framework_TestCase {
 		$this->assertTrue($this->cache->inCache('folder/foobar'));
 		$this->assertTrue($this->cache->inCache('folder/foobar/1'));
 		$this->assertTrue($this->cache->inCache('folder/foobar/2'));
+
+		/* the folder structure of the second user must not change! */
+		$this->assertTrue($this->cache2->inCache('folder/bar'));
+		$this->assertTrue($this->cache2->inCache('folder/foo'));
+		$this->assertTrue($this->cache2->inCache('folder/foo/1'));
+		$this->assertTrue($this->cache2->inCache('folder/foo/2'));
+
+		$this->assertFalse($this->cache2->inCache('folder/foobar'));
+		$this->assertFalse($this->cache2->inCache('folder/foobar/1'));
+		$this->assertFalse($this->cache2->inCache('folder/foobar/2'));
 	}
 
 	function testGetIncomplete() {
@@ -210,6 +238,23 @@ class Cache extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals(array($storageId, 'foo'), \OC\Files\Cache\Cache::getById($id));
 	}
 
+	function testStorageMTime() {
+		$data = array('size' => 1000, 'mtime' => 20, 'mimetype' => 'foo/file');
+		$this->cache->put('foo', $data);
+		$cachedData = $this->cache->get('foo');
+		$this->assertEquals($data['mtime'], $cachedData['storage_mtime']);//if no storage_mtime is saved, mtime should be used
+
+		$this->cache->put('foo', array('storage_mtime' => 30));//when setting storage_mtime, mtime is also set
+		$cachedData = $this->cache->get('foo');
+		$this->assertEquals(30, $cachedData['storage_mtime']);
+		$this->assertEquals(30, $cachedData['mtime']);
+
+		$this->cache->put('foo', array('mtime' => 25));//setting mtime does not change storage_mtime
+		$cachedData = $this->cache->get('foo');
+		$this->assertEquals(30, $cachedData['storage_mtime']);
+		$this->assertEquals(25, $cachedData['mtime']);
+	}
+
 	function testLongId() {
 		$storage = new LongId(array());
 		$cache = $storage->getCache();
@@ -219,12 +264,99 @@ class Cache extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals(array(md5($storageId), 'foo'), \OC\Files\Cache\Cache::getById($id));
 	}
 
+	/**
+	 * @brief this test show the bug resulting if we have no normalizer installed
+	 */
+	public function testWithoutNormalizer() {
+		// folder name "Schön" with U+00F6 (normalized)
+		$folderWith00F6 = "\x53\x63\x68\xc3\xb6\x6e";
+
+		// folder name "Schön" with U+0308 (un-normalized)
+		$folderWith0308 = "\x53\x63\x68\x6f\xcc\x88\x6e";
+
+		/**
+		 * @var \OC\Files\Cache\Cache | PHPUnit_Framework_MockObject_MockObject $cacheMock
+		 */
+		$cacheMock = $this->getMock('\OC\Files\Cache\Cache', array('normalize'), array($this->storage), '', true);
+
+		$cacheMock->expects($this->any())
+			->method('normalize')
+			->will($this->returnArgument(0));
+
+		$data = array('size' => 100, 'mtime' => 50, 'mimetype' => 'httpd/unix-directory');
+
+		// put root folder
+		$this->assertFalse($cacheMock->get('folder'));
+		$this->assertGreaterThan(0, $cacheMock->put('folder', $data));
+
+		// put un-normalized folder
+		$this->assertFalse($cacheMock->get('folder/' .$folderWith0308));
+		$this->assertGreaterThan(0, $cacheMock->put('folder/' .$folderWith0308, $data));
+
+		// get un-normalized folder by name
+		$unNormalizedFolderName = $cacheMock->get('folder/' .$folderWith0308);
+
+		// check if database layer normalized the folder name (this should not happen)
+		$this->assertEquals($folderWith0308, $unNormalizedFolderName['name']);
+
+		// put normalized folder
+		$this->assertFalse($cacheMock->get('folder/' . $folderWith00F6));
+		$this->assertGreaterThan(0, $cacheMock->put('folder/' .$folderWith00F6, $data));
+
+		// this is our bug, we have two different hashes with the same name (Schön)
+		$this->assertEquals(2, count($cacheMock->getFolderContents('folder')));
+	}
+
+	/**
+	 * @brief this test shows that there is no bug if we use the normalizer
+	 */
+	public function testWithNormalizer() {
+
+		if(!class_exists('Patchwork\PHP\Shim\Normalizer')) {
+			$this->markTestSkipped('The 3rdparty Normalizer extension is not available.');
+			return;
+		}
+
+		// folder name "Schön" with U+00F6 (normalized)
+		$folderWith00F6 = "\x53\x63\x68\xc3\xb6\x6e";
+
+		// folder name "Schön" with U+0308 (un-normalized)
+		$folderWith0308 = "\x53\x63\x68\x6f\xcc\x88\x6e";
+
+		$data = array('size' => 100, 'mtime' => 50, 'mimetype' => 'httpd/unix-directory');
+
+		// put root folder
+		$this->assertFalse($this->cache->get('folder'));
+		$this->assertGreaterThan(0, $this->cache->put('folder', $data));
+
+		// put un-normalized folder
+		$this->assertFalse($this->cache->get('folder/' .$folderWith0308));
+		$this->assertGreaterThan(0, $this->cache->put('folder/' .$folderWith0308, $data));
+
+		// get un-normalized folder by name
+		$unNormalizedFolderName = $this->cache->get('folder/' .$folderWith0308);
+
+		// check if folder name was normalized
+		$this->assertEquals($folderWith00F6, $unNormalizedFolderName['name']);
+
+		// put normalized folder
+		$this->assertTrue(is_array($this->cache->get('folder/' . $folderWith00F6)));
+		$this->assertGreaterThan(0, $this->cache->put('folder/' .$folderWith00F6, $data));
+
+		// at this point we should have only one folder named "Schön"
+		$this->assertEquals(1, count($this->cache->getFolderContents('folder')));
+	}
+
 	public function tearDown() {
-		$this->cache->clear();
+		if ($this->cache) {
+			$this->cache->clear();
+		}
 	}
 
 	public function setUp() {
 		$this->storage = new \OC\Files\Storage\Temporary(array());
+		$this->storage2 = new \OC\Files\Storage\Temporary(array());
 		$this->cache = new \OC\Files\Cache\Cache($this->storage);
+		$this->cache2 = new \OC\Files\Cache\Cache($this->storage2);
 	}
 }
diff --git a/tests/lib/files/cache/permissions.php b/tests/lib/files/cache/permissions.php
index 56dbbc4518e..7e6e11e2eb2 100644
--- a/tests/lib/files/cache/permissions.php
+++ b/tests/lib/files/cache/permissions.php
@@ -14,8 +14,8 @@ class Permissions extends \PHPUnit_Framework_TestCase {
 	 */
 	private $permissionsCache;
 
-	function setUp(){
-		$this->permissionsCache=new \OC\Files\Cache\Permissions('dummy');
+	function setUp() {
+		$this->permissionsCache = new \OC\Files\Cache\Permissions('dummy');
 	}
 
 	function testSimple() {
@@ -23,8 +23,10 @@ class Permissions extends \PHPUnit_Framework_TestCase {
 		$user = uniqid();
 
 		$this->assertEquals(-1, $this->permissionsCache->get(1, $user));
+		$this->assertNotContains($user, $this->permissionsCache->getUsers(1));
 		$this->permissionsCache->set(1, $user, 1);
 		$this->assertEquals(1, $this->permissionsCache->get(1, $user));
+		$this->assertContains($user, $this->permissionsCache->getUsers(1));
 		$this->assertEquals(-1, $this->permissionsCache->get(2, $user));
 		$this->assertEquals(-1, $this->permissionsCache->get(1, $user . '2'));
 
diff --git a/tests/lib/files/cache/scanner.php b/tests/lib/files/cache/scanner.php
index 3885c99e6d3..263ceadccc7 100644
--- a/tests/lib/files/cache/scanner.php
+++ b/tests/lib/files/cache/scanner.php
@@ -104,7 +104,7 @@ class Scanner extends \PHPUnit_Framework_TestCase {
 		$this->assertNotEquals($cachedDataFolder['size'], -1);
 	}
 
-	function testBackgroundScan(){
+	function testBackgroundScan() {
 		$this->fillTestFolders();
 		$this->storage->mkdir('folder2');
 		$this->storage->file_put_contents('folder2/bar.txt', 'foobar');
@@ -126,6 +126,46 @@ class Scanner extends \PHPUnit_Framework_TestCase {
 		$this->assertFalse($this->cache->getIncomplete());
 	}
 
+	public function testReuseExisting() {
+		$this->fillTestFolders();
+
+		$this->scanner->scan('');
+		$oldData = $this->cache->get('');
+		$this->storage->unlink('folder/bar.txt');
+		$this->cache->put('folder', array('mtime' => $this->storage->filemtime('folder')));
+		$this->scanner->scan('', \OC\Files\Cache\Scanner::SCAN_SHALLOW, \OC\Files\Cache\Scanner::REUSE_SIZE);
+		$newData = $this->cache->get('');
+		$this->assertNotEquals($oldData['etag'], $newData['etag']);
+		$this->assertEquals($oldData['size'], $newData['size']);
+
+		$oldData = $newData;
+		$this->scanner->scan('', \OC\Files\Cache\Scanner::SCAN_SHALLOW, \OC\Files\Cache\Scanner::REUSE_ETAG);
+		$newData = $this->cache->get('');
+		$this->assertEquals($oldData['etag'], $newData['etag']);
+		$this->assertEquals(-1, $newData['size']);
+	}
+
+	public function testRemovedFile() {
+		$this->fillTestFolders();
+
+		$this->scanner->scan('');
+		$this->assertTrue($this->cache->inCache('foo.txt'));
+		$this->storage->unlink('foo.txt');
+		$this->scanner->scan('', \OC\Files\Cache\Scanner::SCAN_SHALLOW);
+		$this->assertFalse($this->cache->inCache('foo.txt'));
+	}
+
+	public function testRemovedFolder() {
+		$this->fillTestFolders();
+
+		$this->scanner->scan('');
+		$this->assertTrue($this->cache->inCache('folder/bar.txt'));
+		$this->storage->unlink('/folder');
+		$this->scanner->scan('', \OC\Files\Cache\Scanner::SCAN_SHALLOW);
+		$this->assertFalse($this->cache->inCache('folder'));
+		$this->assertFalse($this->cache->inCache('folder/bar.txt'));
+	}
+
 	function setUp() {
 		$this->storage = new \OC\Files\Storage\Temporary(array());
 		$this->scanner = new \OC\Files\Cache\Scanner($this->storage);
@@ -133,9 +173,11 @@ class Scanner extends \PHPUnit_Framework_TestCase {
 	}
 
 	function tearDown() {
-		$ids = $this->cache->getAll();
-		$permissionsCache = $this->storage->getPermissionsCache();
-		$permissionsCache->removeMultiple($ids, \OC_User::getUser());
-		$this->cache->clear();
+		if ($this->cache) {
+			$ids = $this->cache->getAll();
+			$permissionsCache = $this->storage->getPermissionsCache();
+			$permissionsCache->removeMultiple($ids, \OC_User::getUser());
+			$this->cache->clear();
+		}
 	}
 }
diff --git a/tests/lib/files/cache/updater.php b/tests/lib/files/cache/updater.php
index aaf932c97fe..5d7997b0544 100644
--- a/tests/lib/files/cache/updater.php
+++ b/tests/lib/files/cache/updater.php
@@ -42,14 +42,11 @@ class Updater extends \PHPUnit_Framework_TestCase {
 		$this->scanner->scan('');
 		$this->cache = $this->storage->getCache();
 
+		\OC\Files\Filesystem::tearDown();
 		if (!self::$user) {
-			if (!\OC\Files\Filesystem::getView()) {
-				self::$user = uniqid();
-				\OC\Files\Filesystem::init(self::$user, '/' . self::$user . '/files');
-			} else {
-				self::$user = \OC_User::getUser();
-			}
+			self::$user = uniqid();
 		}
+		\OC\Files\Filesystem::init(self::$user, '/' . self::$user . '/files');
 
 		Filesystem::clearMounts();
 		Filesystem::mount($this->storage, array(), '/' . self::$user . '/files');
@@ -59,7 +56,7 @@ class Updater extends \PHPUnit_Framework_TestCase {
 		\OC_Hook::connect('OC_Filesystem', 'post_write', '\OC\Files\Cache\Updater', 'writeHook');
 		\OC_Hook::connect('OC_Filesystem', 'post_delete', '\OC\Files\Cache\Updater', 'deleteHook');
 		\OC_Hook::connect('OC_Filesystem', 'post_rename', '\OC\Files\Cache\Updater', 'renameHook');
-
+		\OC_Hook::connect('OC_Filesystem', 'post_touch', '\OC\Files\Cache\Updater', 'touchHook');
 	}
 
 	public function tearDown() {
@@ -72,6 +69,7 @@ class Updater extends \PHPUnit_Framework_TestCase {
 	public function testWrite() {
 		$textSize = strlen("dummy file data\n");
 		$imageSize = filesize(\OC::$SERVERROOT . '/core/img/logo.png');
+		$this->cache->put('foo.txt', array('mtime' => 100));
 		$rootCachedData = $this->cache->get('');
 		$this->assertEquals(3 * $textSize + $imageSize, $rootCachedData['size']);
 
@@ -80,11 +78,9 @@ class Updater extends \PHPUnit_Framework_TestCase {
 		$cachedData = $this->cache->get('foo.txt');
 		$this->assertEquals(3, $cachedData['size']);
 		$this->assertNotEquals($fooCachedData['etag'], $cachedData['etag']);
-		$mtime = $cachedData['mtime'];
 		$cachedData = $this->cache->get('');
 		$this->assertEquals(2 * $textSize + $imageSize + 3, $cachedData['size']);
 		$this->assertNotEquals($rootCachedData['etag'], $cachedData['etag']);
-		$this->assertGreaterThanOrEqual($rootCachedData['mtime'], $mtime);
 		$rootCachedData = $cachedData;
 
 		$this->assertFalse($this->cache->inCache('bar.txt'));
@@ -99,6 +95,27 @@ class Updater extends \PHPUnit_Framework_TestCase {
 		$this->assertGreaterThanOrEqual($rootCachedData['mtime'], $mtime);
 	}
 
+	public function testWriteWithMountPoints() {
+		$storage2 = new \OC\Files\Storage\Temporary(array());
+		$cache2 = $storage2->getCache();
+		Filesystem::mount($storage2, array(), '/' . self::$user . '/files/folder/substorage');
+		$folderCachedData = $this->cache->get('folder');
+		$substorageCachedData = $cache2->get('');
+		Filesystem::file_put_contents('folder/substorage/foo.txt', 'asd');
+		$this->assertTrue($cache2->inCache('foo.txt'));
+		$cachedData = $cache2->get('foo.txt');
+		$this->assertEquals(3, $cachedData['size']);
+		$mtime = $cachedData['mtime'];
+
+		$cachedData = $cache2->get('');
+		$this->assertNotEquals($substorageCachedData['etag'], $cachedData['etag']);
+		$this->assertEquals($mtime, $cachedData['mtime']);
+
+		$cachedData = $this->cache->get('folder');
+		$this->assertNotEquals($folderCachedData['etag'], $cachedData['etag']);
+		$this->assertEquals($mtime, $cachedData['mtime']);
+	}
+
 	public function testDelete() {
 		$textSize = strlen("dummy file data\n");
 		$imageSize = filesize(\OC::$SERVERROOT . '/core/img/logo.png');
@@ -106,7 +123,7 @@ class Updater extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals(3 * $textSize + $imageSize, $rootCachedData['size']);
 
 		$this->assertTrue($this->cache->inCache('foo.txt'));
-		Filesystem::unlink('foo.txt', 'asd');
+		Filesystem::unlink('foo.txt');
 		$this->assertFalse($this->cache->inCache('foo.txt'));
 		$cachedData = $this->cache->get('');
 		$this->assertEquals(2 * $textSize + $imageSize, $cachedData['size']);
@@ -126,6 +143,26 @@ class Updater extends \PHPUnit_Framework_TestCase {
 		$this->assertGreaterThanOrEqual($rootCachedData['mtime'], $cachedData['mtime']);
 	}
 
+	public function testDeleteWithMountPoints() {
+		$storage2 = new \OC\Files\Storage\Temporary(array());
+		$cache2 = $storage2->getCache();
+		Filesystem::mount($storage2, array(), '/' . self::$user . '/files/folder/substorage');
+		Filesystem::file_put_contents('folder/substorage/foo.txt', 'asd');
+		$this->assertTrue($cache2->inCache('foo.txt'));
+		$folderCachedData = $this->cache->get('folder');
+		$substorageCachedData = $cache2->get('');
+		Filesystem::unlink('folder/substorage/foo.txt');
+		$this->assertFalse($cache2->inCache('foo.txt'));
+
+		$cachedData = $cache2->get('');
+		$this->assertNotEquals($substorageCachedData['etag'], $cachedData['etag']);
+		$this->assertGreaterThanOrEqual($substorageCachedData['mtime'], $cachedData['mtime']);
+
+		$cachedData = $this->cache->get('folder');
+		$this->assertNotEquals($folderCachedData['etag'], $cachedData['etag']);
+		$this->assertGreaterThanOrEqual($folderCachedData['mtime'], $cachedData['mtime']);
+	}
+
 	public function testRename() {
 		$textSize = strlen("dummy file data\n");
 		$imageSize = filesize(\OC::$SERVERROOT . '/core/img/logo.png');
@@ -145,4 +182,87 @@ class Updater extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals(3 * $textSize + $imageSize, $cachedData['size']);
 		$this->assertNotEquals($rootCachedData['etag'], $cachedData['etag']);
 	}
+
+	public function testRenameWithMountPoints() {
+		$storage2 = new \OC\Files\Storage\Temporary(array());
+		$cache2 = $storage2->getCache();
+		Filesystem::mount($storage2, array(), '/' . self::$user . '/files/folder/substorage');
+		Filesystem::file_put_contents('folder/substorage/foo.txt', 'asd');
+		$this->assertTrue($cache2->inCache('foo.txt'));
+		$folderCachedData = $this->cache->get('folder');
+		$substorageCachedData = $cache2->get('');
+		$fooCachedData = $cache2->get('foo.txt');
+		Filesystem::rename('folder/substorage/foo.txt', 'folder/substorage/bar.txt');
+		$this->assertFalse($cache2->inCache('foo.txt'));
+		$this->assertTrue($cache2->inCache('bar.txt'));
+		$cachedData = $cache2->get('bar.txt');
+		$this->assertEquals($fooCachedData['fileid'], $cachedData['fileid']);
+		$mtime = $cachedData['mtime'];
+
+		$cachedData = $cache2->get('');
+		$this->assertNotEquals($substorageCachedData['etag'], $cachedData['etag']);
+		// rename can cause mtime change - invalid assert
+//		$this->assertEquals($mtime, $cachedData['mtime']);
+
+		$cachedData = $this->cache->get('folder');
+		$this->assertNotEquals($folderCachedData['etag'], $cachedData['etag']);
+		// rename can cause mtime change - invalid assert
+//		$this->assertEquals($mtime, $cachedData['mtime']);
+	}
+
+	public function testTouch() {
+		$rootCachedData = $this->cache->get('');
+		$fooCachedData = $this->cache->get('foo.txt');
+		Filesystem::touch('foo.txt');
+		$cachedData = $this->cache->get('foo.txt');
+		$this->assertNotEquals($fooCachedData['etag'], $cachedData['etag']);
+		$this->assertGreaterThanOrEqual($fooCachedData['mtime'], $cachedData['mtime']);
+
+		$cachedData = $this->cache->get('');
+		$this->assertNotEquals($rootCachedData['etag'], $cachedData['etag']);
+		$this->assertGreaterThanOrEqual($rootCachedData['mtime'], $cachedData['mtime']);
+		$rootCachedData = $cachedData;
+
+		$time = 1371006070;
+		$barCachedData = $this->cache->get('folder/bar.txt');
+		$folderCachedData = $this->cache->get('folder');
+		Filesystem::touch('folder/bar.txt', $time);
+		$cachedData = $this->cache->get('folder/bar.txt');
+		$this->assertNotEquals($barCachedData['etag'], $cachedData['etag']);
+		$this->assertEquals($time, $cachedData['mtime']);
+
+		$cachedData = $this->cache->get('folder');
+		$this->assertNotEquals($folderCachedData['etag'], $cachedData['etag']);
+		$this->assertEquals($time, $cachedData['mtime']);
+
+		$cachedData = $this->cache->get('');
+		$this->assertNotEquals($rootCachedData['etag'], $cachedData['etag']);
+		$this->assertEquals($time, $cachedData['mtime']);
+	}
+
+	public function testTouchWithMountPoints() {
+		$storage2 = new \OC\Files\Storage\Temporary(array());
+		$cache2 = $storage2->getCache();
+		Filesystem::mount($storage2, array(), '/' . self::$user . '/files/folder/substorage');
+		Filesystem::file_put_contents('folder/substorage/foo.txt', 'asd');
+		$this->assertTrue($cache2->inCache('foo.txt'));
+		$folderCachedData = $this->cache->get('folder');
+		$substorageCachedData = $cache2->get('');
+		$fooCachedData = $cache2->get('foo.txt');
+		$cachedData = $cache2->get('foo.txt');
+		$time = 1371006070;
+		Filesystem::touch('folder/substorage/foo.txt', $time);
+		$cachedData = $cache2->get('foo.txt');
+		$this->assertNotEquals($fooCachedData['etag'], $cachedData['etag']);
+		$this->assertEquals($time, $cachedData['mtime']);
+
+		$cachedData = $cache2->get('');
+		$this->assertNotEquals($substorageCachedData['etag'], $cachedData['etag']);
+		$this->assertEquals($time, $cachedData['mtime']);
+
+		$cachedData = $this->cache->get('folder');
+		$this->assertNotEquals($folderCachedData['etag'], $cachedData['etag']);
+		$this->assertEquals($time, $cachedData['mtime']);
+	}
+
 }
diff --git a/tests/lib/files/cache/watcher.php b/tests/lib/files/cache/watcher.php
index 8ef6ab44d10..749b1ab75a3 100644
--- a/tests/lib/files/cache/watcher.php
+++ b/tests/lib/files/cache/watcher.php
@@ -29,13 +29,16 @@ class Watcher extends \PHPUnit_Framework_TestCase {
 		}
 	}
 
+	/**
+	 * @medium
+	 */
 	function testWatcher() {
 		$storage = $this->getTestStorage();
 		$cache = $storage->getCache();
 		$updater = $storage->getWatcher();
 
 		//set the mtime to the past so it can detect an mtime change
-		$cache->put('', array('mtime' => 10));
+		$cache->put('', array('storage_mtime' => 10));
 
 		$this->assertTrue($cache->inCache('folder/bar.txt'));
 		$this->assertTrue($cache->inCache('folder/bar2.txt'));
@@ -47,14 +50,14 @@ class Watcher extends \PHPUnit_Framework_TestCase {
 		$cachedData = $cache->get('bar.test');
 		$this->assertEquals(3, $cachedData['size']);
 
-		$cache->put('bar.test', array('mtime' => 10));
+		$cache->put('bar.test', array('storage_mtime' => 10));
 		$storage->file_put_contents('bar.test', 'test data');
 
 		$updater->checkUpdate('bar.test');
 		$cachedData = $cache->get('bar.test');
 		$this->assertEquals(9, $cachedData['size']);
 
-		$cache->put('folder', array('mtime' => 10));
+		$cache->put('folder', array('storage_mtime' => 10));
 
 		$storage->unlink('folder/bar2.txt');
 		$updater->checkUpdate('folder');
@@ -63,13 +66,16 @@ class Watcher extends \PHPUnit_Framework_TestCase {
 		$this->assertFalse($cache->inCache('folder/bar2.txt'));
 	}
 
+	/**
+	 * @medium
+	 */
 	public function testFileToFolder() {
 		$storage = $this->getTestStorage();
 		$cache = $storage->getCache();
 		$updater = $storage->getWatcher();
 
 		//set the mtime to the past so it can detect an mtime change
-		$cache->put('', array('mtime' => 10));
+		$cache->put('', array('storage_mtime' => 10));
 
 		$storage->unlink('foo.txt');
 		$storage->rename('folder', 'foo.txt');
@@ -85,7 +91,7 @@ class Watcher extends \PHPUnit_Framework_TestCase {
 		$updater = $storage->getWatcher();
 
 		//set the mtime to the past so it can detect an mtime change
-		$cache->put('foo.txt', array('mtime' => 10));
+		$cache->put('foo.txt', array('storage_mtime' => 10));
 
 		$storage->unlink('foo.txt');
 		$storage->rename('folder', 'foo.txt');
diff --git a/tests/lib/files/filesystem.php b/tests/lib/files/filesystem.php
index 6ce45e6178a..bef70cc725b 100644
--- a/tests/lib/files/filesystem.php
+++ b/tests/lib/files/filesystem.php
@@ -72,7 +72,7 @@ class Filesystem extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals('/path', \OC\Files\Filesystem::normalizePath('\path'));
 		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('/foo//bar/'));
 		$this->assertEquals('/foo/bar', \OC\Files\Filesystem::normalizePath('/foo////bar'));
-		if (class_exists('Normalizer')) {
+		if (class_exists('Patchwork\PHP\Shim\Normalizer')) {
 			$this->assertEquals("/foo/bar\xC3\xBC", \OC\Files\Filesystem::normalizePath("/foo/baru\xCC\x88"));
 		}
 	}
diff --git a/tests/lib/files/mapper.php b/tests/lib/files/mapper.php
new file mode 100644
index 00000000000..48ae95b7e72
--- /dev/null
+++ b/tests/lib/files/mapper.php
@@ -0,0 +1,64 @@
+<?php
+/**
+ * ownCloud
+ *
+ * @author Thomas Müller
+ * @copyright 2013 Thomas Müller thomas.mueller@owncloud.com
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU AFFERO GENERAL PUBLIC LICENSE for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+namespace Test\Files;
+
+class Mapper extends \PHPUnit_Framework_TestCase {
+
+	/**
+	 * @var \OC\Files\Mapper
+	 */
+	private $mapper = null;
+
+	public function setUp() {
+		$this->mapper = new \OC\Files\Mapper('D:/');
+	}
+
+	public function testSlugifyPath() {
+		// with extension
+		$this->assertEquals('D:/text.txt', $this->mapper->slugifyPath('D:/text.txt'));
+		$this->assertEquals('D:/text-2.txt', $this->mapper->slugifyPath('D:/text.txt', 2));
+		$this->assertEquals('D:/a/b/text.txt', $this->mapper->slugifyPath('D:/a/b/text.txt'));
+
+		// without extension
+		$this->assertEquals('D:/text', $this->mapper->slugifyPath('D:/text'));
+		$this->assertEquals('D:/text-2', $this->mapper->slugifyPath('D:/text', 2));
+		$this->assertEquals('D:/a/b/text', $this->mapper->slugifyPath('D:/a/b/text'));
+
+		// with double dot
+		$this->assertEquals('D:/text.text.txt', $this->mapper->slugifyPath('D:/text.text.txt'));
+		$this->assertEquals('D:/text.text-2.txt', $this->mapper->slugifyPath('D:/text.text.txt', 2));
+		$this->assertEquals('D:/a/b/text.text.txt', $this->mapper->slugifyPath('D:/a/b/text.text.txt'));
+			
+		// foldername and filename with periods
+		$this->assertEquals('D:/folder.name.with.periods', $this->mapper->slugifyPath('D:/folder.name.with.periods'));
+		$this->assertEquals('D:/folder.name.with.periods/test-2.txt', $this->mapper->slugifyPath('D:/folder.name.with.periods/test.txt', 2));
+		$this->assertEquals('D:/folder.name.with.periods/test.txt', $this->mapper->slugifyPath('D:/folder.name.with.periods/test.txt'));
+
+		// foldername and filename with periods and spaces
+		$this->assertEquals('D:/folder.name.with.peri-ods', $this->mapper->slugifyPath('D:/folder.name.with.peri ods'));
+		$this->assertEquals('D:/folder.name.with.peri-ods/te-st-2.t-x-t', $this->mapper->slugifyPath('D:/folder.name.with.peri ods/te st.t x t', 2));
+		$this->assertEquals('D:/folder.name.with.peri-ods/te-st.t-x-t', $this->mapper->slugifyPath('D:/folder.name.with.peri ods/te st.t x t'));
+
+		
+	}
+}
diff --git a/tests/lib/files/mount.php b/tests/lib/files/mount.php
deleted file mode 100644
index a3dc06cc668..00000000000
--- a/tests/lib/files/mount.php
+++ /dev/null
@@ -1,58 +0,0 @@
-<?php
-/**
- * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
- * This file is licensed under the Affero General Public License version 3 or
- * later.
- * See the COPYING-README file.
- */
-
-namespace Test\Files;
-
-use \OC\Files\Storage\Temporary;
-
-class LongId extends Temporary {
-	public function getId() {
-		return 'long:' . str_repeat('foo', 50) . parent::getId();
-	}
-}
-
-class Mount extends \PHPUnit_Framework_TestCase {
-	public function setup() {
-		\OC_Util::setupFS();
-		\OC\Files\Mount::clear();
-	}
-
-	public function testFind() {
-		$this->assertNull(\OC\Files\Mount::find('/'));
-
-		$rootMount = new \OC\Files\Mount(new Temporary(array()), '/');
-		$this->assertEquals($rootMount, \OC\Files\Mount::find('/'));
-		$this->assertEquals($rootMount, \OC\Files\Mount::find('/foo/bar'));
-
-		$storage = new Temporary(array());
-		$mount = new \OC\Files\Mount($storage, '/foo');
-		$this->assertEquals($rootMount, \OC\Files\Mount::find('/'));
-		$this->assertEquals($mount, \OC\Files\Mount::find('/foo/bar'));
-
-		$this->assertEquals(1, count(\OC\Files\Mount::findIn('/')));
-		new \OC\Files\Mount(new Temporary(array()), '/bar');
-		$this->assertEquals(2, count(\OC\Files\Mount::findIn('/')));
-
-		$id = $mount->getStorageId();
-		$this->assertEquals(array($mount), \OC\Files\Mount::findByStorageId($id));
-
-		$mount2 = new \OC\Files\Mount($storage, '/foo/bar');
-		$this->assertEquals(array($mount, $mount2), \OC\Files\Mount::findByStorageId($id));
-	}
-
-	public function testLong() {
-		$storage = new LongId(array());
-		$mount = new \OC\Files\Mount($storage, '/foo');
-
-		$id = $mount->getStorageId();
-		$storageId = $storage->getId();
-		$this->assertEquals(array($mount), \OC\Files\Mount::findByStorageId($id));
-		$this->assertEquals(array($mount), \OC\Files\Mount::findByStorageId($storageId));
-		$this->assertEquals(array($mount), \OC\Files\Mount::findByStorageId(md5($storageId)));
-	}
-}
diff --git a/tests/lib/files/mount/manager.php b/tests/lib/files/mount/manager.php
new file mode 100644
index 00000000000..154c35ccead
--- /dev/null
+++ b/tests/lib/files/mount/manager.php
@@ -0,0 +1,67 @@
+<?php
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\Files\Mount;
+
+use \OC\Files\Storage\Temporary;
+
+class LongId extends Temporary {
+	public function getId() {
+		return 'long:' . str_repeat('foo', 50) . parent::getId();
+	}
+}
+
+class Manager extends \PHPUnit_Framework_TestCase {
+	/**
+	 * @var \OC\Files\Mount\Manager
+	 */
+	private $manager;
+
+	public function setup() {
+		$this->manager = new \OC\Files\Mount\Manager();
+	}
+
+	public function testFind() {
+		$this->assertNull($this->manager->find('/'));
+
+		$rootMount = new \OC\Files\Mount\Mount(new Temporary(array()), '/');
+		$this->manager->addMount($rootMount);
+		$this->assertEquals($rootMount, $this->manager->find('/'));
+		$this->assertEquals($rootMount, $this->manager->find('/foo/bar'));
+
+		$storage = new Temporary(array());
+		$mount1 = new \OC\Files\Mount\Mount($storage, '/foo');
+		$this->manager->addMount($mount1);
+		$this->assertEquals($rootMount, $this->manager->find('/'));
+		$this->assertEquals($mount1, $this->manager->find('/foo/bar'));
+
+		$this->assertEquals(1, count($this->manager->findIn('/')));
+		$mount2 = new \OC\Files\Mount\Mount(new Temporary(array()), '/bar');
+		$this->manager->addMount($mount2);
+		$this->assertEquals(2, count($this->manager->findIn('/')));
+
+		$id = $mount1->getStorageId();
+		$this->assertEquals(array($mount1), $this->manager->findByStorageId($id));
+
+		$mount3 = new \OC\Files\Mount\Mount($storage, '/foo/bar');
+		$this->manager->addMount($mount3);
+		$this->assertEquals(array($mount1, $mount3), $this->manager->findByStorageId($id));
+	}
+
+	public function testLong() {
+		$storage = new LongId(array());
+		$mount = new \OC\Files\Mount\Mount($storage, '/foo');
+		$this->manager->addMount($mount);
+
+		$id = $mount->getStorageId();
+		$storageId = $storage->getId();
+		$this->assertEquals(array($mount), $this->manager->findByStorageId($id));
+		$this->assertEquals(array($mount), $this->manager->findByStorageId($storageId));
+		$this->assertEquals(array($mount), $this->manager->findByStorageId(md5($storageId)));
+	}
+}
diff --git a/tests/lib/files/mount/mount.php b/tests/lib/files/mount/mount.php
new file mode 100644
index 00000000000..b057204ad35
--- /dev/null
+++ b/tests/lib/files/mount/mount.php
@@ -0,0 +1,46 @@
+<?php
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\Files\Mount;
+
+
+use OC\Files\Storage\Loader;
+use OC\Files\Storage\Wrapper\Wrapper;
+
+class Mount extends \PHPUnit_Framework_TestCase {
+	public function testFromStorageObject() {
+		$storage = $this->getMockBuilder('\OC\Files\Storage\Temporary')
+			->disableOriginalConstructor()
+			->getMock();
+		$mount = new \OC\Files\Mount\Mount($storage, '/foo');
+		$this->assertInstanceOf('\OC\Files\Storage\Temporary', $mount->getStorage());
+	}
+
+	public function testFromStorageClassname() {
+		$mount = new \OC\Files\Mount\Mount('\OC\Files\Storage\Temporary', '/foo');
+		$this->assertInstanceOf('\OC\Files\Storage\Temporary', $mount->getStorage());
+	}
+
+	public function testWrapper() {
+		$test = $this;
+		$wrapper = function ($mountPoint, $storage) use (&$test) {
+			$test->assertEquals('/foo/', $mountPoint);
+			$test->assertInstanceOf('\OC\Files\Storage\Storage', $storage);
+			return new Wrapper(array('storage' => $storage));
+		};
+
+		$loader = new Loader();
+		$loader->addStorageWrapper($wrapper);
+
+		$storage = $this->getMockBuilder('\OC\Files\Storage\Temporary')
+			->disableOriginalConstructor()
+			->getMock();
+		$mount = new \OC\Files\Mount\Mount($storage, '/foo', array(), $loader);
+		$this->assertInstanceOf('\OC\Files\Storage\Wrapper\Wrapper', $mount->getStorage());
+	}
+}
diff --git a/tests/lib/files/storage/storage.php b/tests/lib/files/storage/storage.php
index 3d68efea5fc..fb3e05e66b3 100644
--- a/tests/lib/files/storage/storage.php
+++ b/tests/lib/files/storage/storage.php
@@ -257,4 +257,22 @@ abstract class Storage extends \PHPUnit_Framework_TestCase {
 		$content = stream_get_contents($fh);
 		$this->assertEquals(file_get_contents($textFile), $content);
 	}
+
+	public function testTouchCreateFile() {
+		$this->assertFalse($this->instance->file_exists('foo'));
+		$this->instance->touch('foo');
+		$this->assertTrue($this->instance->file_exists('foo'));
+	}
+
+	public function testRecursiveRmdir() {
+		$this->instance->mkdir('folder');
+		$this->instance->mkdir('folder/bar');
+		$this->instance->file_put_contents('folder/asd.txt', 'foobar');
+		$this->instance->file_put_contents('folder/bar/foo.txt', 'asd');
+		$this->instance->rmdir('folder');
+		$this->assertFalse($this->instance->file_exists('folder/asd.txt'));
+		$this->assertFalse($this->instance->file_exists('folder/bar/foo.txt'));
+		$this->assertFalse($this->instance->file_exists('folder/bar'));
+		$this->assertFalse($this->instance->file_exists('folder'));
+	}
 }
diff --git a/tests/lib/files/storage/wrapper.php b/tests/lib/files/storage/wrapper.php
new file mode 100644
index 00000000000..2794a0a6263
--- /dev/null
+++ b/tests/lib/files/storage/wrapper.php
@@ -0,0 +1,26 @@
+<?php
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\Files\Storage;
+
+class Wrapper extends Storage {
+	/**
+	 * @var string tmpDir
+	 */
+	private $tmpDir;
+
+	public function setUp() {
+		$this->tmpDir = \OC_Helper::tmpFolder();
+		$storage = new \OC\Files\Storage\Local(array('datadir' => $this->tmpDir));
+		$this->instance = new \OC\Files\Storage\Wrapper\Wrapper(array('storage' => $storage));
+	}
+
+	public function tearDown() {
+		\OC_Helper::rmdirr($this->tmpDir);
+	}
+}
diff --git a/tests/lib/files/stream/staticstream.php b/tests/lib/files/stream/staticstream.php
new file mode 100644
index 00000000000..d55086196a0
--- /dev/null
+++ b/tests/lib/files/stream/staticstream.php
@@ -0,0 +1,68 @@
+<?php
+/**
+ * Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+namespace Test\Files\Stream;
+
+class StaticStream extends \PHPUnit_Framework_TestCase {
+
+	private $sourceFile;
+	private $sourceText;
+
+	public function __construct() {
+		$this->sourceFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+		$this->sourceText = file_get_contents($this->sourceFile);
+	}
+
+	public function tearDown() {
+		\OC\Files\Stream\StaticStream::clear();
+	}
+
+	public function testContent() {
+		file_put_contents('static://foo', $this->sourceText);
+		$this->assertEquals($this->sourceText, file_get_contents('static://foo'));
+	}
+
+	public function testMultipleFiles() {
+		file_put_contents('static://foo', $this->sourceText);
+		file_put_contents('static://bar', strrev($this->sourceText));
+		$this->assertEquals($this->sourceText, file_get_contents('static://foo'));
+		$this->assertEquals(strrev($this->sourceText), file_get_contents('static://bar'));
+	}
+
+	public function testOverwrite() {
+		file_put_contents('static://foo', $this->sourceText);
+		file_put_contents('static://foo', 'qwerty');
+		$this->assertEquals('qwerty', file_get_contents('static://foo'));
+	}
+
+	public function testIsFile() {
+		$this->assertFalse(is_file('static://foo'));
+		file_put_contents('static://foo', $this->sourceText);
+		$this->assertTrue(is_file('static://foo'));
+	}
+
+	public function testIsDir() {
+		$this->assertFalse(is_dir('static://foo'));
+		file_put_contents('static://foo', $this->sourceText);
+		$this->assertFalse(is_dir('static://foo'));
+	}
+
+	public function testFileType() {
+		file_put_contents('static://foo', $this->sourceText);
+		$this->assertEquals('file', filetype('static://foo'));
+	}
+
+	public function testUnlink() {
+		$this->assertFalse(file_exists('static://foo'));
+		file_put_contents('static://foo', $this->sourceText);
+		$this->assertTrue(file_exists('static://foo'));
+		unlink('static://foo');
+		clearstatcache();
+		$this->assertFalse(file_exists('static://foo'));
+	}
+}
diff --git a/tests/lib/files/view.php b/tests/lib/files/view.php
index a064e44f3ef..830913a91ad 100644
--- a/tests/lib/files/view.php
+++ b/tests/lib/files/view.php
@@ -7,6 +7,12 @@
 
 namespace Test\Files;
 
+class TemporaryNoTouch extends \OC\Files\Storage\Temporary {
+	public function touch($path, $mtime = null) {
+		return false;
+	}
+}
+
 class View extends \PHPUnit_Framework_TestCase {
 	/**
 	 * @var \OC\Files\Storage\Storage[] $storages;
@@ -27,6 +33,9 @@ class View extends \PHPUnit_Framework_TestCase {
 		}
 	}
 
+	/**
+	 * @medium
+	 */
 	public function testCacheAPI() {
 		$storage1 = $this->getTestStorage();
 		$storage2 = $this->getTestStorage();
@@ -98,6 +107,9 @@ class View extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals(array(), $rootView->getDirectoryContent('/non/existing'));
 	}
 
+	/**
+	 * @medium
+	 */
 	function testGetPath() {
 		$storage1 = $this->getTestStorage();
 		$storage2 = $this->getTestStorage();
@@ -121,6 +133,9 @@ class View extends \PHPUnit_Framework_TestCase {
 		$this->assertNull($folderView->getPath($id1));
 	}
 
+	/**
+	 * @medium
+	 */
 	function testMountPointOverwrite() {
 		$storage1 = $this->getTestStorage(false);
 		$storage2 = $this->getTestStorage();
@@ -164,6 +179,9 @@ class View extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals($textSize, $folderData[0]['size']);
 	}
 
+	/**
+	 * @medium
+	 */
 	function testSearch() {
 		$storage1 = $this->getTestStorage();
 		$storage2 = $this->getTestStorage();
@@ -211,6 +229,9 @@ class View extends \PHPUnit_Framework_TestCase {
 		$this->assertEquals(3, count($folderView->searchByMime('text')));
 	}
 
+	/**
+	 * @medium
+	 */
 	function testWatcher() {
 		$storage1 = $this->getTestStorage();
 		\OC\Files\Filesystem::mount($storage1, array(), '/');
@@ -220,7 +241,7 @@ class View extends \PHPUnit_Framework_TestCase {
 		$cachedData = $rootView->getFileInfo('foo.txt');
 		$this->assertEquals(16, $cachedData['size']);
 
-		$rootView->putFileInfo('foo.txt', array('mtime' => 10));
+		$rootView->putFileInfo('foo.txt', array('storage_mtime' => 10));
 		$storage1->file_put_contents('foo.txt', 'foo');
 		clearstatcache();
 
@@ -229,11 +250,81 @@ class View extends \PHPUnit_Framework_TestCase {
 	}
 
 	/**
+	 * @medium
+	 */
+	function testCopyBetweenStorages() {
+		$storage1 = $this->getTestStorage();
+		$storage2 = $this->getTestStorage();
+		\OC\Files\Filesystem::mount($storage1, array(), '/');
+		\OC\Files\Filesystem::mount($storage2, array(), '/substorage');
+
+		$rootView = new \OC\Files\View('');
+		$rootView->mkdir('substorage/emptyfolder');
+		$rootView->copy('substorage', 'anotherfolder');
+		$this->assertTrue($rootView->is_dir('/anotherfolder'));
+		$this->assertTrue($rootView->is_dir('/substorage'));
+		$this->assertTrue($rootView->is_dir('/anotherfolder/emptyfolder'));
+		$this->assertTrue($rootView->is_dir('/substorage/emptyfolder'));
+		$this->assertTrue($rootView->file_exists('/anotherfolder/foo.txt'));
+		$this->assertTrue($rootView->file_exists('/anotherfolder/foo.png'));
+		$this->assertTrue($rootView->file_exists('/anotherfolder/folder/bar.txt'));
+		$this->assertTrue($rootView->file_exists('/substorage/foo.txt'));
+		$this->assertTrue($rootView->file_exists('/substorage/foo.png'));
+		$this->assertTrue($rootView->file_exists('/substorage/folder/bar.txt'));
+	}
+
+	/**
+	 * @medium
+	 */
+	function testMoveBetweenStorages() {
+		$storage1 = $this->getTestStorage();
+		$storage2 = $this->getTestStorage();
+		\OC\Files\Filesystem::mount($storage1, array(), '/');
+		\OC\Files\Filesystem::mount($storage2, array(), '/substorage');
+
+		$rootView = new \OC\Files\View('');
+		$rootView->rename('foo.txt', 'substorage/folder/foo.txt');
+		$this->assertFalse($rootView->file_exists('foo.txt'));
+		$this->assertTrue($rootView->file_exists('substorage/folder/foo.txt'));
+		$rootView->rename('substorage/folder', 'anotherfolder');
+		$this->assertFalse($rootView->is_dir('substorage/folder'));
+		$this->assertTrue($rootView->file_exists('anotherfolder/foo.txt'));
+		$this->assertTrue($rootView->file_exists('anotherfolder/bar.txt'));
+	}
+
+	/**
+	 * @medium
+	 */
+	function testTouch() {
+		$storage = $this->getTestStorage(true, '\Test\Files\TemporaryNoTouch');
+
+		\OC\Files\Filesystem::mount($storage, array(), '/');
+
+		$rootView = new \OC\Files\View('');
+		$oldCachedData = $rootView->getFileInfo('foo.txt');
+
+		$rootView->touch('foo.txt', 500);
+
+		$cachedData = $rootView->getFileInfo('foo.txt');
+		$this->assertEquals(500, $cachedData['mtime']);
+		$this->assertEquals($oldCachedData['storage_mtime'], $cachedData['storage_mtime']);
+
+		$rootView->putFileInfo('foo.txt', array('storage_mtime' => 1000)); //make sure the watcher detects the change
+		$rootView->file_put_contents('foo.txt', 'asd');
+		$cachedData = $rootView->getFileInfo('foo.txt');
+		$this->assertGreaterThanOrEqual($cachedData['mtime'], $oldCachedData['mtime']);
+		$this->assertEquals($cachedData['storage_mtime'], $cachedData['mtime']);
+	}
+
+	/**
 	 * @param bool $scan
 	 * @return \OC\Files\Storage\Storage
 	 */
-	private function getTestStorage($scan = true) {
-		$storage = new \OC\Files\Storage\Temporary(array());
+	private function getTestStorage($scan = true, $class = '\OC\Files\Storage\Temporary') {
+		/**
+		 * @var \OC\Files\Storage\Storage $storage
+		 */
+		$storage = new $class(array());
 		$textData = "dummy file data\n";
 		$imgData = file_get_contents(\OC::$SERVERROOT . '/core/img/logo.png');
 		$storage->mkdir('folder');