aboutsummaryrefslogtreecommitdiffstats
path: root/tests/lib/files
diff options
context:
space:
mode:
Diffstat (limited to 'tests/lib/files')
-rw-r--r--tests/lib/files/cache/cache.php215
-rw-r--r--tests/lib/files/cache/permissions.php56
-rw-r--r--tests/lib/files/cache/scanner.php141
-rw-r--r--tests/lib/files/cache/updater.php147
-rw-r--r--tests/lib/files/cache/watcher.php121
-rw-r--r--tests/lib/files/filesystem.php110
-rw-r--r--tests/lib/files/mount.php41
-rw-r--r--tests/lib/files/storage/commontest.php41
-rw-r--r--tests/lib/files/storage/local.php39
-rw-r--r--tests/lib/files/storage/storage.php236
-rw-r--r--tests/lib/files/view.php251
11 files changed, 1398 insertions, 0 deletions
diff --git a/tests/lib/files/cache/cache.php b/tests/lib/files/cache/cache.php
new file mode 100644
index 00000000000..c466fbb63e7
--- /dev/null
+++ b/tests/lib/files/cache/cache.php
@@ -0,0 +1,215 @@
+<?php
+/**
+ * Copyright (c) 2012 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\Cache;
+
+class Cache extends \PHPUnit_Framework_TestCase {
+ /**
+ * @var \OC\Files\Storage\Temporary $storage;
+ */
+ private $storage;
+
+ /**
+ * @var \OC\Files\Cache\Cache $cache
+ */
+ private $cache;
+
+ public function testSimple() {
+ $file1 = 'foo';
+ $file2 = 'foo/bar';
+ $data1 = array('size' => 100, 'mtime' => 50, 'mimetype' => 'foo/folder');
+ $data2 = array('size' => 1000, 'mtime' => 20, 'mimetype' => 'foo/file');
+
+ $this->assertFalse($this->cache->inCache($file1));
+ $this->assertEquals($this->cache->get($file1), null);
+
+ $id1 = $this->cache->put($file1, $data1);
+ $this->assertTrue($this->cache->inCache($file1));
+ $cacheData1 = $this->cache->get($file1);
+ foreach ($data1 as $key => $value) {
+ $this->assertEquals($value, $cacheData1[$key]);
+ }
+ $this->assertEquals($cacheData1['mimepart'], 'foo');
+ $this->assertEquals($cacheData1['fileid'], $id1);
+ $this->assertEquals($id1, $this->cache->getId($file1));
+
+ $this->assertFalse($this->cache->inCache($file2));
+ $id2 = $this->cache->put($file2, $data2);
+ $this->assertTrue($this->cache->inCache($file2));
+ $cacheData2 = $this->cache->get($file2);
+ foreach ($data2 as $key => $value) {
+ $this->assertEquals($value, $cacheData2[$key]);
+ }
+ $this->assertEquals($cacheData1['fileid'], $cacheData2['parent']);
+ $this->assertEquals($cacheData2['fileid'], $id2);
+ $this->assertEquals($id2, $this->cache->getId($file2));
+ $this->assertEquals($id1, $this->cache->getParentId($file2));
+
+ $newSize = 1050;
+ $newId2 = $this->cache->put($file2, array('size' => $newSize));
+ $cacheData2 = $this->cache->get($file2);
+ $this->assertEquals($newId2, $id2);
+ $this->assertEquals($cacheData2['size'], $newSize);
+ $this->assertEquals($cacheData1, $this->cache->get($file1));
+
+ $this->cache->remove($file2);
+ $this->assertFalse($this->cache->inCache($file2));
+ $this->assertEquals($this->cache->get($file2), null);
+ $this->assertTrue($this->cache->inCache($file1));
+
+ $this->assertEquals($cacheData1, $this->cache->get($id1));
+ }
+
+ public function testPartial() {
+ $file1 = 'foo';
+
+ $this->cache->put($file1, array('size' => 10));
+ $this->assertEquals(array('size' => 10), $this->cache->get($file1));
+
+ $this->cache->put($file1, array('mtime' => 15));
+ $this->assertEquals(array('size' => 10, 'mtime' => 15), $this->cache->get($file1));
+
+ $this->cache->put($file1, array('size' => 12));
+ $this->assertEquals(array('size' => 12, 'mtime' => 15), $this->cache->get($file1));
+ }
+
+ public function testFolder() {
+ $file1 = 'folder';
+ $file2 = 'folder/bar';
+ $file3 = 'folder/foo';
+ $data1 = array('size' => 100, 'mtime' => 50, 'mimetype' => 'httpd/unix-directory');
+ $fileData = array();
+ $fileData['bar'] = array('size' => 1000, 'mtime' => 20, 'mimetype' => 'foo/file');
+ $fileData['foo'] = array('size' => 20, 'mtime' => 25, 'mimetype' => 'foo/file');
+
+ $this->cache->put($file1, $data1);
+ $this->cache->put($file2, $fileData['bar']);
+ $this->cache->put($file3, $fileData['foo']);
+
+ $content = $this->cache->getFolderContents($file1);
+ $this->assertEquals(count($content), 2);
+ foreach ($content as $cachedData) {
+ $data = $fileData[$cachedData['name']];
+ foreach ($data as $name => $value) {
+ $this->assertEquals($value, $cachedData[$name]);
+ }
+ }
+
+ $file4 = 'folder/unkownSize';
+ $fileData['unkownSize'] = array('size' => -1, 'mtime' => 25, 'mimetype' => 'foo/file');
+ $this->cache->put($file4, $fileData['unkownSize']);
+
+ $this->assertEquals(-1, $this->cache->calculateFolderSize($file1));
+
+ $fileData['unkownSize'] = array('size' => 5, 'mtime' => 25, 'mimetype' => 'foo/file');
+ $this->cache->put($file4, $fileData['unkownSize']);
+
+ $this->assertEquals(1025, $this->cache->calculateFolderSize($file1));
+
+ $this->cache->remove('folder');
+ $this->assertFalse($this->cache->inCache('folder/foo'));
+ $this->assertFalse($this->cache->inCache('folder/bar'));
+ }
+
+ function testStatus() {
+ $this->assertEquals(\OC\Files\Cache\Cache::NOT_FOUND, $this->cache->getStatus('foo'));
+ $this->cache->put('foo', array('size' => -1));
+ $this->assertEquals(\OC\Files\Cache\Cache::PARTIAL, $this->cache->getStatus('foo'));
+ $this->cache->put('foo', array('size' => -1, 'mtime' => 20, 'mimetype' => 'foo/file'));
+ $this->assertEquals(\OC\Files\Cache\Cache::SHALLOW, $this->cache->getStatus('foo'));
+ $this->cache->put('foo', array('size' => 10));
+ $this->assertEquals(\OC\Files\Cache\Cache::COMPLETE, $this->cache->getStatus('foo'));
+ }
+
+ function testSearch() {
+ $file1 = 'folder';
+ $file2 = 'folder/foobar';
+ $file3 = 'folder/foo';
+ $data1 = array('size' => 100, 'mtime' => 50, 'mimetype' => 'foo/folder');
+ $fileData = array();
+ $fileData['foobar'] = array('size' => 1000, 'mtime' => 20, 'mimetype' => 'foo/file');
+ $fileData['foo'] = array('size' => 20, 'mtime' => 25, 'mimetype' => 'foo/file');
+
+ $this->cache->put($file1, $data1);
+ $this->cache->put($file2, $fileData['foobar']);
+ $this->cache->put($file3, $fileData['foo']);
+
+ $this->assertEquals(2, count($this->cache->search('%foo%')));
+ $this->assertEquals(1, count($this->cache->search('foo')));
+ $this->assertEquals(1, count($this->cache->search('%folder%')));
+ $this->assertEquals(1, count($this->cache->search('folder%')));
+ $this->assertEquals(3, count($this->cache->search('%')));
+
+ $this->assertEquals(3, count($this->cache->searchByMime('foo')));
+ $this->assertEquals(2, count($this->cache->searchByMime('foo/file')));
+ }
+
+ function testMove() {
+ $file1 = 'folder';
+ $file2 = 'folder/bar';
+ $file3 = 'folder/foo';
+ $file4 = 'folder/foo/1';
+ $file5 = 'folder/foo/2';
+ $data = array('size' => 100, 'mtime' => 50, 'mimetype' => 'foo/bar');
+
+ $this->cache->put($file1, $data);
+ $this->cache->put($file2, $data);
+ $this->cache->put($file3, $data);
+ $this->cache->put($file4, $data);
+ $this->cache->put($file5, $data);
+
+ $this->cache->move('folder/foo', 'folder/foobar');
+
+ $this->assertFalse($this->cache->inCache('folder/foo'));
+ $this->assertFalse($this->cache->inCache('folder/foo/1'));
+ $this->assertFalse($this->cache->inCache('folder/foo/2'));
+
+ $this->assertTrue($this->cache->inCache('folder/bar'));
+ $this->assertTrue($this->cache->inCache('folder/foobar'));
+ $this->assertTrue($this->cache->inCache('folder/foobar/1'));
+ $this->assertTrue($this->cache->inCache('folder/foobar/2'));
+ }
+
+ function testGetIncomplete() {
+ $file1 = 'folder1';
+ $file2 = 'folder2';
+ $file3 = 'folder3';
+ $file4 = 'folder4';
+ $data = array('size' => 10, 'mtime' => 50, 'mimetype' => 'foo/bar');
+
+ $this->cache->put($file1, $data);
+ $data['size'] = -1;
+ $this->cache->put($file2, $data);
+ $this->cache->put($file3, $data);
+ $data['size'] = 12;
+ $this->cache->put($file4, $data);
+
+ $this->assertEquals($file3, $this->cache->getIncomplete());
+ }
+
+ function testNonExisting() {
+ $this->assertFalse($this->cache->get('foo.txt'));
+ $this->assertEquals(array(), $this->cache->getFolderContents('foo'));
+ }
+
+ function testGetById() {
+ $storageId = $this->storage->getId();
+ $data = array('size' => 1000, 'mtime' => 20, 'mimetype' => 'foo/file');
+ $id = $this->cache->put('foo', $data);
+ $this->assertEquals(array($storageId, 'foo'), \OC\Files\Cache\Cache::getById($id));
+ }
+
+ public function tearDown() {
+ $this->cache->clear();
+ }
+
+ public function setUp() {
+ $this->storage = new \OC\Files\Storage\Temporary(array());
+ $this->cache = new \OC\Files\Cache\Cache($this->storage);
+ }
+}
diff --git a/tests/lib/files/cache/permissions.php b/tests/lib/files/cache/permissions.php
new file mode 100644
index 00000000000..56dbbc4518e
--- /dev/null
+++ b/tests/lib/files/cache/permissions.php
@@ -0,0 +1,56 @@
+<?php
+/**
+ * Copyright (c) 2012 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\Cache;
+
+class Permissions extends \PHPUnit_Framework_TestCase {
+ /***
+ * @var \OC\Files\Cache\Permissions $permissionsCache
+ */
+ private $permissionsCache;
+
+ function setUp(){
+ $this->permissionsCache=new \OC\Files\Cache\Permissions('dummy');
+ }
+
+ function testSimple() {
+ $ids = range(1, 10);
+ $user = uniqid();
+
+ $this->assertEquals(-1, $this->permissionsCache->get(1, $user));
+ $this->permissionsCache->set(1, $user, 1);
+ $this->assertEquals(1, $this->permissionsCache->get(1, $user));
+ $this->assertEquals(-1, $this->permissionsCache->get(2, $user));
+ $this->assertEquals(-1, $this->permissionsCache->get(1, $user . '2'));
+
+ $this->permissionsCache->set(1, $user, 2);
+ $this->assertEquals(2, $this->permissionsCache->get(1, $user));
+
+ $this->permissionsCache->set(2, $user, 1);
+ $this->assertEquals(1, $this->permissionsCache->get(2, $user));
+
+ $this->permissionsCache->remove(1, $user);
+ $this->assertEquals(-1, $this->permissionsCache->get(1, $user));
+ $this->permissionsCache->remove(1, $user . '2');
+ $this->assertEquals(1, $this->permissionsCache->get(2, $user));
+
+ $expected = array();
+ foreach ($ids as $id) {
+ $this->permissionsCache->set($id, $user, 10 + $id);
+ $expected[$id] = 10 + $id;
+ }
+ $this->assertEquals($expected, $this->permissionsCache->getMultiple($ids, $user));
+
+ $this->permissionsCache->removeMultiple(array(10, 9), $user);
+ unset($expected[9]);
+ unset($expected[10]);
+ $this->assertEquals($expected, $this->permissionsCache->getMultiple($ids, $user));
+
+ $this->permissionsCache->removeMultiple($ids, $user);
+ }
+}
diff --git a/tests/lib/files/cache/scanner.php b/tests/lib/files/cache/scanner.php
new file mode 100644
index 00000000000..3885c99e6d3
--- /dev/null
+++ b/tests/lib/files/cache/scanner.php
@@ -0,0 +1,141 @@
+<?php
+/**
+ * Copyright (c) 2012 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\Cache;
+
+class Scanner extends \PHPUnit_Framework_TestCase {
+ /**
+ * @var \OC\Files\Storage\Storage $storage
+ */
+ private $storage;
+
+ /**
+ * @var \OC\Files\Cache\Scanner $scanner
+ */
+ private $scanner;
+
+ /**
+ * @var \OC\Files\Cache\Cache $cache
+ */
+ private $cache;
+
+ function testFile() {
+ $data = "dummy file data\n";
+ $this->storage->file_put_contents('foo.txt', $data);
+ $this->scanner->scanFile('foo.txt');
+
+ $this->assertEquals($this->cache->inCache('foo.txt'), true);
+ $cachedData = $this->cache->get('foo.txt');
+ $this->assertEquals($cachedData['size'], strlen($data));
+ $this->assertEquals($cachedData['mimetype'], 'text/plain');
+ $this->assertNotEquals($cachedData['parent'], -1); //parent folders should be scanned automatically
+
+ $data = file_get_contents(\OC::$SERVERROOT . '/core/img/logo.png');
+ $this->storage->file_put_contents('foo.png', $data);
+ $this->scanner->scanFile('foo.png');
+
+ $this->assertEquals($this->cache->inCache('foo.png'), true);
+ $cachedData = $this->cache->get('foo.png');
+ $this->assertEquals($cachedData['size'], strlen($data));
+ $this->assertEquals($cachedData['mimetype'], 'image/png');
+ }
+
+ private function fillTestFolders() {
+ $textData = "dummy file data\n";
+ $imgData = file_get_contents(\OC::$SERVERROOT . '/core/img/logo.png');
+ $this->storage->mkdir('folder');
+ $this->storage->file_put_contents('foo.txt', $textData);
+ $this->storage->file_put_contents('foo.png', $imgData);
+ $this->storage->file_put_contents('folder/bar.txt', $textData);
+ }
+
+ function testFolder() {
+ $this->fillTestFolders();
+
+ $this->scanner->scan('');
+ $this->assertEquals($this->cache->inCache(''), true);
+ $this->assertEquals($this->cache->inCache('foo.txt'), true);
+ $this->assertEquals($this->cache->inCache('foo.png'), true);
+ $this->assertEquals($this->cache->inCache('folder'), true);
+ $this->assertEquals($this->cache->inCache('folder/bar.txt'), true);
+
+ $cachedDataText = $this->cache->get('foo.txt');
+ $cachedDataText2 = $this->cache->get('foo.txt');
+ $cachedDataImage = $this->cache->get('foo.png');
+ $cachedDataFolder = $this->cache->get('');
+ $cachedDataFolder2 = $this->cache->get('folder');
+
+ $this->assertEquals($cachedDataImage['parent'], $cachedDataText['parent']);
+ $this->assertEquals($cachedDataFolder['fileid'], $cachedDataImage['parent']);
+ $this->assertEquals($cachedDataFolder['size'], $cachedDataImage['size'] + $cachedDataText['size'] + $cachedDataText2['size']);
+ $this->assertEquals($cachedDataFolder2['size'], $cachedDataText2['size']);
+ }
+
+ function testShallow() {
+ $this->fillTestFolders();
+
+ $this->scanner->scan('', \OC\Files\Cache\Scanner::SCAN_SHALLOW);
+ $this->assertEquals($this->cache->inCache(''), true);
+ $this->assertEquals($this->cache->inCache('foo.txt'), true);
+ $this->assertEquals($this->cache->inCache('foo.png'), true);
+ $this->assertEquals($this->cache->inCache('folder'), true);
+ $this->assertEquals($this->cache->inCache('folder/bar.txt'), false);
+
+ $cachedDataFolder = $this->cache->get('');
+ $cachedDataFolder2 = $this->cache->get('folder');
+
+ $this->assertEquals(-1, $cachedDataFolder['size']);
+ $this->assertEquals(-1, $cachedDataFolder2['size']);
+
+ $this->scanner->scan('folder', \OC\Files\Cache\Scanner::SCAN_SHALLOW);
+
+ $cachedDataFolder2 = $this->cache->get('folder');
+
+ $this->assertNotEquals($cachedDataFolder2['size'], -1);
+
+ $this->cache->correctFolderSize('folder');
+
+ $cachedDataFolder = $this->cache->get('');
+ $this->assertNotEquals($cachedDataFolder['size'], -1);
+ }
+
+ function testBackgroundScan(){
+ $this->fillTestFolders();
+ $this->storage->mkdir('folder2');
+ $this->storage->file_put_contents('folder2/bar.txt', 'foobar');
+
+ $this->scanner->scan('', \OC\Files\Cache\Scanner::SCAN_SHALLOW);
+ $this->assertFalse($this->cache->inCache('folder/bar.txt'));
+ $this->assertFalse($this->cache->inCache('folder/2bar.txt'));
+ $cachedData = $this->cache->get('');
+ $this->assertEquals(-1, $cachedData['size']);
+
+ $this->scanner->backgroundScan();
+
+ $this->assertTrue($this->cache->inCache('folder/bar.txt'));
+ $this->assertTrue($this->cache->inCache('folder/bar.txt'));
+
+ $cachedData = $this->cache->get('');
+ $this->assertnotEquals(-1, $cachedData['size']);
+
+ $this->assertFalse($this->cache->getIncomplete());
+ }
+
+ function setUp() {
+ $this->storage = new \OC\Files\Storage\Temporary(array());
+ $this->scanner = new \OC\Files\Cache\Scanner($this->storage);
+ $this->cache = new \OC\Files\Cache\Cache($this->storage);
+ }
+
+ function tearDown() {
+ $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
new file mode 100644
index 00000000000..b83dd0c26e5
--- /dev/null
+++ b/tests/lib/files/cache/updater.php
@@ -0,0 +1,147 @@
+<?php
+/**
+ * Copyright (c) 2012 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\Cache;
+
+use \OC\Files\Filesystem as Filesystem;
+
+class Updater extends \PHPUnit_Framework_TestCase {
+ /**
+ * @var \OC\Files\Storage\Storage $storage
+ */
+ private $storage;
+
+ /**
+ * @var \OC\Files\Cache\Scanner $scanner
+ */
+ private $scanner;
+
+ /**
+ * @var \OC\Files\Cache\Cache $cache
+ */
+ private $cache;
+
+ private static $user;
+
+ public function setUp() {
+ $this->storage = new \OC\Files\Storage\Temporary(array());
+ $textData = "dummy file data\n";
+ $imgData = file_get_contents(\OC::$SERVERROOT . '/core/img/logo.png');
+ $this->storage->mkdir('folder');
+ $this->storage->file_put_contents('foo.txt', $textData);
+ $this->storage->file_put_contents('foo.png', $imgData);
+ $this->storage->file_put_contents('folder/bar.txt', $textData);
+ $this->storage->file_put_contents('folder/bar2.txt', $textData);
+
+ $this->scanner = $this->storage->getScanner();
+ $this->scanner->scan('');
+ $this->cache = $this->storage->getCache();
+
+ if (!self::$user) {
+ if (!\OC\Files\Filesystem::getView()) {
+ self::$user = uniqid();
+ \OC\Files\Filesystem::init('/' . self::$user . '/files');
+ } else {
+ self::$user = \OC_User::getUser();
+ }
+ }
+
+ Filesystem::clearMounts();
+ Filesystem::mount($this->storage, array(), '/' . self::$user . '/files');
+
+ \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');
+
+ }
+
+ public function tearDown() {
+ if ($this->cache) {
+ $this->cache->clear();
+ }
+ Filesystem::tearDown();
+ }
+
+ public function testWrite() {
+ $textSize = strlen("dummy file data\n");
+ $imageSize = filesize(\OC::$SERVERROOT . '/core/img/logo.png');
+ $rootCachedData = $this->cache->get('');
+ $this->assertEquals(3 * $textSize + $imageSize, $rootCachedData['size']);
+
+ $fooCachedData = $this->cache->get('foo.txt');
+ Filesystem::file_put_contents('foo.txt', 'asd');
+ $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'));
+ Filesystem::file_put_contents('bar.txt', 'asd');
+ $this->assertTrue($this->cache->inCache('bar.txt'));
+ $cachedData = $this->cache->get('bar.txt');
+ $this->assertEquals(3, $cachedData['size']);
+ $mtime = $cachedData['mtime'];
+ $cachedData = $this->cache->get('');
+ $this->assertEquals(2 * $textSize + $imageSize + 2 * 3, $cachedData['size']);
+ $this->assertNotEquals($rootCachedData['etag'], $cachedData['etag']);
+ $this->assertGreaterThanOrEqual($rootCachedData['mtime'], $mtime);
+ }
+
+ public function testDelete() {
+ $textSize = strlen("dummy file data\n");
+ $imageSize = filesize(\OC::$SERVERROOT . '/core/img/logo.png');
+ $rootCachedData = $this->cache->get('');
+ $this->assertEquals(3 * $textSize + $imageSize, $rootCachedData['size']);
+
+ $this->assertTrue($this->cache->inCache('foo.txt'));
+ Filesystem::unlink('foo.txt', 'asd');
+ $this->assertFalse($this->cache->inCache('foo.txt'));
+ $cachedData = $this->cache->get('');
+ $this->assertEquals(2 * $textSize + $imageSize, $cachedData['size']);
+ $this->assertNotEquals($rootCachedData['etag'], $cachedData['etag']);
+ $this->assertGreaterThanOrEqual($rootCachedData['mtime'], $cachedData['mtime']);
+ $rootCachedData = $cachedData;
+
+ Filesystem::mkdir('bar_folder');
+ $this->assertTrue($this->cache->inCache('bar_folder'));
+ $cachedData = $this->cache->get('');
+ $this->assertNotEquals($rootCachedData['etag'], $cachedData['etag']);
+ $rootCachedData = $cachedData;
+ Filesystem::rmdir('bar_folder');
+ $this->assertFalse($this->cache->inCache('bar_folder'));
+ $cachedData = $this->cache->get('');
+ $this->assertNotEquals($rootCachedData['etag'], $cachedData['etag']);
+ $this->assertGreaterThanOrEqual($rootCachedData['mtime'], $cachedData['mtime']);
+ }
+
+ public function testRename() {
+ $textSize = strlen("dummy file data\n");
+ $imageSize = filesize(\OC::$SERVERROOT . '/core/img/logo.png');
+ $rootCachedData = $this->cache->get('');
+ $this->assertEquals(3 * $textSize + $imageSize, $rootCachedData['size']);
+
+ $this->assertTrue($this->cache->inCache('foo.txt'));
+ $fooCachedData = $this->cache->get('foo.txt');
+ $this->assertFalse($this->cache->inCache('bar.txt'));
+ Filesystem::rename('foo.txt', 'bar.txt');
+ $this->assertFalse($this->cache->inCache('foo.txt'));
+ $this->assertTrue($this->cache->inCache('bar.txt'));
+ $cachedData = $this->cache->get('bar.txt');
+ $this->assertNotEquals($fooCachedData['etag'], $cachedData['etag']);
+ $mtime = $cachedData['mtime'];
+ $cachedData = $this->cache->get('');
+ $this->assertEquals(3 * $textSize + $imageSize, $cachedData['size']);
+ $this->assertNotEquals($rootCachedData['etag'], $cachedData['etag']);
+ $this->assertEquals($mtime, $cachedData['mtime']);
+ }
+}
diff --git a/tests/lib/files/cache/watcher.php b/tests/lib/files/cache/watcher.php
new file mode 100644
index 00000000000..e8a1689cab0
--- /dev/null
+++ b/tests/lib/files/cache/watcher.php
@@ -0,0 +1,121 @@
+<?php
+/**
+ * Copyright (c) 2012 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\Cache;
+
+class Watcher extends \PHPUnit_Framework_TestCase {
+
+ /**
+ * @var \OC\Files\Storage\Storage[] $storages;
+ */
+ private $storages = array();
+
+ public function setUp() {
+ \OC\Files\Filesystem::clearMounts();
+ }
+
+ public function tearDown() {
+ foreach ($this->storages as $storage) {
+ $cache = $storage->getCache();
+ $ids = $cache->getAll();
+ $permissionsCache = $storage->getPermissionsCache();
+ $permissionsCache->removeMultiple($ids, \OC_User::getUser());
+ $cache->clear();
+ }
+ }
+
+ 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));
+
+ $this->assertTrue($cache->inCache('folder/bar.txt'));
+ $this->assertTrue($cache->inCache('folder/bar2.txt'));
+
+ $this->assertFalse($cache->inCache('bar.test'));
+ $storage->file_put_contents('bar.test', 'foo');
+ $updater->checkUpdate('');
+ $this->assertTrue($cache->inCache('bar.test'));
+ $cachedData = $cache->get('bar.test');
+ $this->assertEquals(3, $cachedData['size']);
+
+ $cache->put('bar.test', array('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));
+
+ $storage->unlink('folder/bar2.txt');
+ $updater->checkUpdate('folder');
+
+ $this->assertTrue($cache->inCache('folder/bar.txt'));
+ $this->assertFalse($cache->inCache('folder/bar2.txt'));
+ }
+
+ 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));
+
+ $storage->unlink('foo.txt');
+ $storage->rename('folder', 'foo.txt');
+ $updater->checkUpdate('');
+
+ $entry = $cache->get('foo.txt');
+ $this->assertEquals(-1, $entry['size']);
+ $this->assertEquals('httpd/unix-directory', $entry['mimetype']);
+ $this->assertFalse($cache->inCache('folder'));
+ $this->assertFalse($cache->inCache('folder/bar.txt'));
+
+ $storage = $this->getTestStorage();
+ $cache = $storage->getCache();
+ $updater = $storage->getWatcher();
+
+ //set the mtime to the past so it can detect an mtime change
+ $cache->put('foo.txt', array('mtime' => 10));
+
+ $storage->unlink('foo.txt');
+ $storage->rename('folder', 'foo.txt');
+ $updater->checkUpdate('foo.txt');
+
+ $entry = $cache->get('foo.txt');
+ $this->assertEquals('httpd/unix-directory', $entry['mimetype']);
+ $this->assertTrue($cache->inCache('foo.txt/bar.txt'));
+ }
+
+ /**
+ * @param bool $scan
+ * @return \OC\Files\Storage\Storage
+ */
+ private function getTestStorage($scan = true) {
+ $storage = new \OC\Files\Storage\Temporary(array());
+ $textData = "dummy file data\n";
+ $imgData = file_get_contents(\OC::$SERVERROOT . '/core/img/logo.png');
+ $storage->mkdir('folder');
+ $storage->file_put_contents('foo.txt', $textData);
+ $storage->file_put_contents('foo.png', $imgData);
+ $storage->file_put_contents('folder/bar.txt', $textData);
+ $storage->file_put_contents('folder/bar2.txt', $textData);
+
+ if ($scan) {
+ $scanner = $storage->getScanner();
+ $scanner->scan('');
+ }
+ $this->storages[] = $storage;
+ return $storage;
+ }
+}
diff --git a/tests/lib/files/filesystem.php b/tests/lib/files/filesystem.php
new file mode 100644
index 00000000000..5837093fdd6
--- /dev/null
+++ b/tests/lib/files/filesystem.php
@@ -0,0 +1,110 @@
+<?php
+/**
+ * ownCloud
+ *
+ * @author Robin Appelman
+ * @copyright 2012 Robin Appelman icewind@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 Filesystem extends \PHPUnit_Framework_TestCase {
+ /**
+ * @var array tmpDirs
+ */
+ private $tmpDirs=array();
+
+ /**
+ * @return array
+ */
+ private function getStorageData() {
+ $dir = \OC_Helper::tmpFolder();
+ $this->tmpDirs[] = $dir;
+ return array('datadir' => $dir);
+ }
+
+ public function tearDown() {
+ foreach ($this->tmpDirs as $dir) {
+ \OC_Helper::rmdirr($dir);
+ }
+ }
+
+ public function setUp() {
+ \OC\Files\Filesystem::clearMounts();
+ }
+
+ public function testMount() {
+ \OC\Files\Filesystem::mount('\OC\Files\Storage\Local',self::getStorageData(),'/');
+ $this->assertEquals('/',\OC\Files\Filesystem::getMountPoint('/'));
+ $this->assertEquals('/',\OC\Files\Filesystem::getMountPoint('/some/folder'));
+ list( , $internalPath)=\OC\Files\Filesystem::resolvePath('/');
+ $this->assertEquals('',$internalPath);
+ list( , $internalPath)=\OC\Files\Filesystem::resolvePath('/some/folder');
+ $this->assertEquals('some/folder',$internalPath);
+
+ \OC\Files\Filesystem::mount('\OC\Files\Storage\Local',self::getStorageData(),'/some');
+ $this->assertEquals('/',\OC\Files\Filesystem::getMountPoint('/'));
+ $this->assertEquals('/some/',\OC\Files\Filesystem::getMountPoint('/some/folder'));
+ $this->assertEquals('/some/',\OC\Files\Filesystem::getMountPoint('/some/'));
+ $this->assertEquals('/some/',\OC\Files\Filesystem::getMountPoint('/some'));
+ list( , $internalPath)=\OC\Files\Filesystem::resolvePath('/some/folder');
+ $this->assertEquals('folder',$internalPath);
+ }
+
+ public function testNormalize() {
+ $this->assertEquals('/path', \OC\Files\Filesystem::normalizePath('/path/'));
+ $this->assertEquals('/path/', \OC\Files\Filesystem::normalizePath('/path/', false));
+ $this->assertEquals('/path', \OC\Files\Filesystem::normalizePath('path'));
+ $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')) {
+ $this->assertEquals("/foo/bar\xC3\xBC", \OC\Files\Filesystem::normalizePath("/foo/baru\xCC\x88"));
+ }
+ }
+
+ public function testHooks() {
+ if(\OC\Files\Filesystem::getView()){
+ $user = \OC_User::getUser();
+ }else{
+ $user=uniqid();
+ \OC\Files\Filesystem::init('/'.$user.'/files');
+ }
+ \OC_Hook::clear('OC_Filesystem');
+ \OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHook');
+
+ \OC\Files\Filesystem::mount('OC\Files\Storage\Temporary', array(), '/');
+
+ $rootView=new \OC\Files\View('');
+ $rootView->mkdir('/'.$user);
+ $rootView->mkdir('/'.$user.'/files');
+
+ \OC\Files\Filesystem::file_put_contents('/foo', 'foo');
+ \OC\Files\Filesystem::mkdir('/bar');
+ \OC\Files\Filesystem::file_put_contents('/bar//foo', 'foo');
+
+ $tmpFile = \OC_Helper::tmpFile();
+ file_put_contents($tmpFile, 'foo');
+ $fh = fopen($tmpFile, 'r');
+ \OC\Files\Filesystem::file_put_contents('/bar//foo', $fh);
+ }
+
+ public function dummyHook($arguments) {
+ $path = $arguments['path'];
+ $this->assertEquals($path, \OC\Files\Filesystem::normalizePath($path)); //the path passed to the hook should already be normalized
+ }
+}
diff --git a/tests/lib/files/mount.php b/tests/lib/files/mount.php
new file mode 100644
index 00000000000..f223f0f6c53
--- /dev/null
+++ b/tests/lib/files/mount.php
@@ -0,0 +1,41 @@
+<?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 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::findById($id));
+
+ $mount2 = new \OC\Files\Mount($storage, '/foo/bar');
+ $this->assertEquals(array($mount, $mount2), \OC\Files\Mount::findById($id));
+ }
+}
diff --git a/tests/lib/files/storage/commontest.php b/tests/lib/files/storage/commontest.php
new file mode 100644
index 00000000000..744d4608420
--- /dev/null
+++ b/tests/lib/files/storage/commontest.php
@@ -0,0 +1,41 @@
+<?php
+/**
+* ownCloud
+*
+* @author Robin Appelman
+* @copyright 2012 Robin Appelman icewind@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\Storage;
+
+class CommonTest extends Storage {
+ /**
+ * @var string tmpDir
+ */
+ private $tmpDir;
+ public function setUp() {
+ $this->tmpDir=get_temp_dir().'/filestoragecommon';
+ if(!file_exists($this->tmpDir)) {
+ mkdir($this->tmpDir);
+ }
+ $this->instance=new \OC\Files\Storage\CommonTest(array('datadir'=>$this->tmpDir));
+ }
+
+ public function tearDown() {
+ \OC_Helper::rmdirr($this->tmpDir);
+ }
+}
diff --git a/tests/lib/files/storage/local.php b/tests/lib/files/storage/local.php
new file mode 100644
index 00000000000..1aad138aa33
--- /dev/null
+++ b/tests/lib/files/storage/local.php
@@ -0,0 +1,39 @@
+<?php
+/**
+* ownCloud
+*
+* @author Robin Appelman
+* @copyright 2012 Robin Appelman icewind@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\Storage;
+
+class Local extends Storage {
+ /**
+ * @var string tmpDir
+ */
+ private $tmpDir;
+ public function setUp() {
+ $this->tmpDir=\OC_Helper::tmpFolder();
+ $this->instance=new \OC\Files\Storage\Local(array('datadir'=>$this->tmpDir));
+ }
+
+ public function tearDown() {
+ \OC_Helper::rmdirr($this->tmpDir);
+ }
+}
+
diff --git a/tests/lib/files/storage/storage.php b/tests/lib/files/storage/storage.php
new file mode 100644
index 00000000000..781c0f92c92
--- /dev/null
+++ b/tests/lib/files/storage/storage.php
@@ -0,0 +1,236 @@
+<?php
+/**
+ * ownCloud
+ *
+ * @author Robin Appelman
+ * @copyright 2012 Robin Appelman icewind@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\Storage;
+
+abstract class Storage extends \PHPUnit_Framework_TestCase {
+ /**
+ * @var \OC\Files\Storage\Storage instance
+ */
+ protected $instance;
+
+ /**
+ * the root folder of the storage should always exist, be readable and be recognized as a directory
+ */
+ public function testRoot() {
+ $this->assertTrue($this->instance->file_exists('/'), 'Root folder does not exist');
+ $this->assertTrue($this->instance->isReadable('/'), 'Root folder is not readable');
+ $this->assertTrue($this->instance->is_dir('/'), 'Root folder is not a directory');
+ $this->assertFalse($this->instance->is_file('/'), 'Root folder is a file');
+ $this->assertEquals('dir', $this->instance->filetype('/'));
+
+ //without this, any further testing would be useless, not an actual requirement for filestorage though
+ $this->assertTrue($this->instance->isUpdatable('/'), 'Root folder is not writable');
+ }
+
+ public function testDirectories() {
+ $this->assertFalse($this->instance->file_exists('/folder'));
+
+ $this->assertTrue($this->instance->mkdir('/folder'));
+
+ $this->assertTrue($this->instance->file_exists('/folder'));
+ $this->assertTrue($this->instance->is_dir('/folder'));
+ $this->assertFalse($this->instance->is_file('/folder'));
+ $this->assertEquals('dir', $this->instance->filetype('/folder'));
+ $this->assertEquals(0, $this->instance->filesize('/folder'));
+ $this->assertTrue($this->instance->isReadable('/folder'));
+ $this->assertTrue($this->instance->isUpdatable('/folder'));
+
+ $dh = $this->instance->opendir('/');
+ $content = array();
+ while ($file = readdir($dh)) {
+ if ($file != '.' and $file != '..') {
+ $content[] = $file;
+ }
+ }
+ $this->assertEquals(array('folder'), $content);
+
+ $this->assertFalse($this->instance->mkdir('/folder')); //cant create existing folders
+ $this->assertTrue($this->instance->rmdir('/folder'));
+
+ $this->assertFalse($this->instance->file_exists('/folder'));
+
+ $this->assertFalse($this->instance->rmdir('/folder')); //cant remove non existing folders
+
+ $dh = $this->instance->opendir('/');
+ $content = array();
+ while ($file = readdir($dh)) {
+ if ($file != '.' and $file != '..') {
+ $content[] = $file;
+ }
+ }
+ $this->assertEquals(array(), $content);
+ }
+
+ /**
+ * test the various uses of file_get_contents and file_put_contents
+ */
+ public function testGetPutContents() {
+ $sourceFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+ $sourceText = file_get_contents($sourceFile);
+
+ //fill a file with string data
+ $this->instance->file_put_contents('/lorem.txt', $sourceText);
+ $this->assertFalse($this->instance->is_dir('/lorem.txt'));
+ $this->assertEquals($sourceText, $this->instance->file_get_contents('/lorem.txt'), 'data returned from file_get_contents is not equal to the source data');
+
+ //empty the file
+ $this->instance->file_put_contents('/lorem.txt', '');
+ $this->assertEquals('', $this->instance->file_get_contents('/lorem.txt'), 'file not emptied');
+ }
+
+ /**
+ * test various known mimetypes
+ */
+ public function testMimeType() {
+ $this->assertEquals('httpd/unix-directory', $this->instance->getMimeType('/'));
+ $this->assertEquals(false, $this->instance->getMimeType('/non/existing/file'));
+
+ $textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+ $this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile, 'r'));
+ $this->assertEquals('text/plain', $this->instance->getMimeType('/lorem.txt'));
+
+ $pngFile = \OC::$SERVERROOT . '/tests/data/logo-wide.png';
+ $this->instance->file_put_contents('/logo-wide.png', file_get_contents($pngFile, 'r'));
+ $this->assertEquals('image/png', $this->instance->getMimeType('/logo-wide.png'));
+
+ $svgFile = \OC::$SERVERROOT . '/tests/data/logo-wide.svg';
+ $this->instance->file_put_contents('/logo-wide.svg', file_get_contents($svgFile, 'r'));
+ $this->assertEquals('image/svg+xml', $this->instance->getMimeType('/logo-wide.svg'));
+ }
+
+ public function testCopyAndMove() {
+ $textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+ $this->instance->file_put_contents('/source.txt', file_get_contents($textFile));
+ $this->instance->copy('/source.txt', '/target.txt');
+ $this->assertTrue($this->instance->file_exists('/target.txt'));
+ $this->assertEquals($this->instance->file_get_contents('/source.txt'), $this->instance->file_get_contents('/target.txt'));
+
+ $this->instance->rename('/source.txt', '/target2.txt');
+ $this->assertTrue($this->instance->file_exists('/target2.txt'));
+ $this->assertFalse($this->instance->file_exists('/source.txt'));
+ $this->assertEquals(file_get_contents($textFile), $this->instance->file_get_contents('/target.txt'));
+ }
+
+ public function testLocal() {
+ $textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+ $this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
+ $localFile = $this->instance->getLocalFile('/lorem.txt');
+ $this->assertTrue(file_exists($localFile));
+ $this->assertEquals(file_get_contents($localFile), file_get_contents($textFile));
+
+ $this->instance->mkdir('/folder');
+ $this->instance->file_put_contents('/folder/lorem.txt', file_get_contents($textFile));
+ $this->instance->file_put_contents('/folder/bar.txt', 'asd');
+ $this->instance->mkdir('/folder/recursive');
+ $this->instance->file_put_contents('/folder/recursive/file.txt', 'foo');
+ $localFolder = $this->instance->getLocalFolder('/folder');
+
+ $this->assertTrue(is_dir($localFolder));
+ $this->assertTrue(file_exists($localFolder . '/lorem.txt'));
+ $this->assertEquals(file_get_contents($localFolder . '/lorem.txt'), file_get_contents($textFile));
+ $this->assertEquals(file_get_contents($localFolder . '/bar.txt'), 'asd');
+ $this->assertEquals(file_get_contents($localFolder . '/recursive/file.txt'), 'foo');
+ }
+
+ public function testStat() {
+ $textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+ $ctimeStart = time();
+ $this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
+ $this->assertTrue($this->instance->isReadable('/lorem.txt'));
+ $ctimeEnd = time();
+ $mTime = $this->instance->filemtime('/lorem.txt');
+ $this->assertTrue($this->instance->hasUpdated('/lorem.txt', $ctimeStart - 1));
+ $this->assertTrue($this->instance->hasUpdated('/', $ctimeStart - 1));
+
+ $this->assertTrue(($ctimeStart - 1) <= $mTime);
+ $this->assertTrue($mTime <= ($ctimeEnd + 1));
+ $this->assertEquals(filesize($textFile), $this->instance->filesize('/lorem.txt'));
+
+ $stat = $this->instance->stat('/lorem.txt');
+ //only size and mtime are requered in the result
+ $this->assertEquals($stat['size'], $this->instance->filesize('/lorem.txt'));
+ $this->assertEquals($stat['mtime'], $mTime);
+
+ $mtimeStart = time();
+ $supportsTouch = $this->instance->touch('/lorem.txt');
+ $mtimeEnd = time();
+ if ($supportsTouch !== false) {
+ $mTime = $this->instance->filemtime('/lorem.txt');
+ $this->assertTrue(($mtimeStart - 1) <= $mTime);
+ $this->assertTrue($mTime <= ($mtimeEnd + 1));
+
+ $this->assertTrue($this->instance->hasUpdated('/lorem.txt', $mtimeStart - 1));
+
+ if ($this->instance->touch('/lorem.txt', 100) !== false) {
+ $mTime = $this->instance->filemtime('/lorem.txt');
+ $this->assertEquals($mTime, 100);
+ }
+ }
+
+ $mtimeStart = time();
+ $fh = $this->instance->fopen('/lorem.txt', 'a');
+ fwrite($fh, ' ');
+ fclose($fh);
+ clearstatcache();
+ $mtimeEnd = time();
+ $mTime = $this->instance->filemtime('/lorem.txt');
+ $this->assertTrue(($mtimeStart - 1) <= $mTime);
+ $this->assertTrue($mTime <= ($mtimeEnd + 1));
+
+ $this->instance->unlink('/lorem.txt');
+ $this->assertTrue($this->instance->hasUpdated('/', $mtimeStart - 1));
+ }
+
+ public function testSearch() {
+ $textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+ $this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile, 'r'));
+ $pngFile = \OC::$SERVERROOT . '/tests/data/logo-wide.png';
+ $this->instance->file_put_contents('/logo-wide.png', file_get_contents($pngFile, 'r'));
+ $svgFile = \OC::$SERVERROOT . '/tests/data/logo-wide.svg';
+ $this->instance->file_put_contents('/logo-wide.svg', file_get_contents($svgFile, 'r'));
+ $result = $this->instance->search('logo');
+ $this->assertEquals(2, count($result));
+ $this->assertContains('/logo-wide.svg', $result);
+ $this->assertContains('/logo-wide.png', $result);
+ }
+
+ public function testFOpen() {
+ $textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+
+ $fh = @$this->instance->fopen('foo', 'r');
+ if ($fh) {
+ fclose($fh);
+ }
+ $this->assertFalse($fh);
+ $this->assertFalse($this->instance->file_exists('foo'));
+
+ $fh = $this->instance->fopen('foo', 'w');
+ fwrite($fh, file_get_contents($textFile));
+ fclose($fh);
+ $this->assertTrue($this->instance->file_exists('foo'));
+
+ $fh = $this->instance->fopen('foo', 'r');
+ $content = stream_get_contents($fh);
+ $this->assertEquals(file_get_contents($textFile), $content);
+ }
+}
diff --git a/tests/lib/files/view.php b/tests/lib/files/view.php
new file mode 100644
index 00000000000..a064e44f3ef
--- /dev/null
+++ b/tests/lib/files/view.php
@@ -0,0 +1,251 @@
+<?php
+/**
+ * Copyright (c) 2012 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;
+
+class View extends \PHPUnit_Framework_TestCase {
+ /**
+ * @var \OC\Files\Storage\Storage[] $storages;
+ */
+ private $storages = array();
+
+ public function setUp() {
+ \OC\Files\Filesystem::clearMounts();
+ }
+
+ public function tearDown() {
+ foreach ($this->storages as $storage) {
+ $cache = $storage->getCache();
+ $ids = $cache->getAll();
+ $permissionsCache = $storage->getPermissionsCache();
+ $permissionsCache->removeMultiple($ids, \OC_User::getUser());
+ $cache->clear();
+ }
+ }
+
+ public function testCacheAPI() {
+ $storage1 = $this->getTestStorage();
+ $storage2 = $this->getTestStorage();
+ $storage3 = $this->getTestStorage();
+ \OC\Files\Filesystem::mount($storage1, array(), '/');
+ \OC\Files\Filesystem::mount($storage2, array(), '/substorage');
+ \OC\Files\Filesystem::mount($storage3, array(), '/folder/anotherstorage');
+ $textSize = strlen("dummy file data\n");
+ $imageSize = filesize(\OC::$SERVERROOT . '/core/img/logo.png');
+ $storageSize = $textSize * 2 + $imageSize;
+
+ $rootView = new \OC\Files\View('');
+
+ $cachedData = $rootView->getFileInfo('/foo.txt');
+ $this->assertEquals($textSize, $cachedData['size']);
+ $this->assertEquals('text/plain', $cachedData['mimetype']);
+ $this->assertNotEquals(-1, $cachedData['permissions']);
+
+ $cachedData = $rootView->getFileInfo('/');
+ $this->assertEquals($storageSize * 3, $cachedData['size']);
+ $this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
+
+ $cachedData = $rootView->getFileInfo('/folder');
+ $this->assertEquals($storageSize + $textSize, $cachedData['size']);
+ $this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
+
+ $folderData = $rootView->getDirectoryContent('/');
+ /**
+ * expected entries:
+ * folder
+ * foo.png
+ * foo.txt
+ * substorage
+ */
+ $this->assertEquals(4, count($folderData));
+ $this->assertEquals('folder', $folderData[0]['name']);
+ $this->assertEquals('foo.png', $folderData[1]['name']);
+ $this->assertEquals('foo.txt', $folderData[2]['name']);
+ $this->assertEquals('substorage', $folderData[3]['name']);
+
+ $this->assertEquals($storageSize + $textSize, $folderData[0]['size']);
+ $this->assertEquals($imageSize, $folderData[1]['size']);
+ $this->assertEquals($textSize, $folderData[2]['size']);
+ $this->assertEquals($storageSize, $folderData[3]['size']);
+
+ $folderData = $rootView->getDirectoryContent('/substorage');
+ /**
+ * expected entries:
+ * folder
+ * foo.png
+ * foo.txt
+ */
+ $this->assertEquals(3, count($folderData));
+ $this->assertEquals('folder', $folderData[0]['name']);
+ $this->assertEquals('foo.png', $folderData[1]['name']);
+ $this->assertEquals('foo.txt', $folderData[2]['name']);
+
+ $folderView = new \OC\Files\View('/folder');
+ $this->assertEquals($rootView->getFileInfo('/folder'), $folderView->getFileInfo('/'));
+
+ $cachedData = $rootView->getFileInfo('/foo.txt');
+ $this->assertFalse($cachedData['encrypted']);
+ $id = $rootView->putFileInfo('/foo.txt', array('encrypted' => true));
+ $cachedData = $rootView->getFileInfo('/foo.txt');
+ $this->assertTrue($cachedData['encrypted']);
+ $this->assertEquals($cachedData['fileid'], $id);
+
+ $this->assertFalse($rootView->getFileInfo('/non/existing'));
+ $this->assertEquals(array(), $rootView->getDirectoryContent('/non/existing'));
+ }
+
+ function testGetPath() {
+ $storage1 = $this->getTestStorage();
+ $storage2 = $this->getTestStorage();
+ $storage3 = $this->getTestStorage();
+ \OC\Files\Filesystem::mount($storage1, array(), '/');
+ \OC\Files\Filesystem::mount($storage2, array(), '/substorage');
+ \OC\Files\Filesystem::mount($storage3, array(), '/folder/anotherstorage');
+
+ $rootView = new \OC\Files\View('');
+
+ $cachedData = $rootView->getFileInfo('/foo.txt');
+ $id1 = $cachedData['fileid'];
+ $this->assertEquals('/foo.txt', $rootView->getPath($id1));
+
+ $cachedData = $rootView->getFileInfo('/substorage/foo.txt');
+ $id2 = $cachedData['fileid'];
+ $this->assertEquals('/substorage/foo.txt', $rootView->getPath($id2));
+
+ $folderView = new \OC\Files\View('/substorage');
+ $this->assertEquals('/foo.txt', $folderView->getPath($id2));
+ $this->assertNull($folderView->getPath($id1));
+ }
+
+ function testMountPointOverwrite() {
+ $storage1 = $this->getTestStorage(false);
+ $storage2 = $this->getTestStorage();
+ $storage1->mkdir('substorage');
+ \OC\Files\Filesystem::mount($storage1, array(), '/');
+ \OC\Files\Filesystem::mount($storage2, array(), '/substorage');
+
+ $rootView = new \OC\Files\View('');
+ $folderContent = $rootView->getDirectoryContent('/');
+ $this->assertEquals(4, count($folderContent));
+ }
+
+ function testCacheIncompleteFolder() {
+ $storage1 = $this->getTestStorage(false);
+ \OC\Files\Filesystem::mount($storage1, array(), '/');
+ $rootView = new \OC\Files\View('');
+
+ $entries = $rootView->getDirectoryContent('/');
+ $this->assertEquals(3, count($entries));
+
+ // /folder will already be in the cache but not scanned
+ $entries = $rootView->getDirectoryContent('/folder');
+ $this->assertEquals(1, count($entries));
+ }
+
+ public function testAutoScan() {
+ $storage1 = $this->getTestStorage(false);
+ $storage2 = $this->getTestStorage(false);
+ \OC\Files\Filesystem::mount($storage1, array(), '/');
+ \OC\Files\Filesystem::mount($storage2, array(), '/substorage');
+ $textSize = strlen("dummy file data\n");
+
+ $rootView = new \OC\Files\View('');
+
+ $cachedData = $rootView->getFileInfo('/');
+ $this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
+ $this->assertEquals(-1, $cachedData['size']);
+
+ $folderData = $rootView->getDirectoryContent('/substorage/folder');
+ $this->assertEquals('text/plain', $folderData[0]['mimetype']);
+ $this->assertEquals($textSize, $folderData[0]['size']);
+ }
+
+ function testSearch() {
+ $storage1 = $this->getTestStorage();
+ $storage2 = $this->getTestStorage();
+ $storage3 = $this->getTestStorage();
+ \OC\Files\Filesystem::mount($storage1, array(), '/');
+ \OC\Files\Filesystem::mount($storage2, array(), '/substorage');
+ \OC\Files\Filesystem::mount($storage3, array(), '/folder/anotherstorage');
+
+ $rootView = new \OC\Files\View('');
+
+ $results = $rootView->search('foo');
+ $this->assertEquals(6, count($results));
+ $paths = array();
+ foreach ($results as $result) {
+ $this->assertEquals($result['path'], \OC\Files\Filesystem::normalizePath($result['path']));
+ $paths[] = $result['path'];
+ }
+ $this->assertContains('/foo.txt', $paths);
+ $this->assertContains('/foo.png', $paths);
+ $this->assertContains('/substorage/foo.txt', $paths);
+ $this->assertContains('/substorage/foo.png', $paths);
+ $this->assertContains('/folder/anotherstorage/foo.txt', $paths);
+ $this->assertContains('/folder/anotherstorage/foo.png', $paths);
+
+ $folderView = new \OC\Files\View('/folder');
+ $results = $folderView->search('bar');
+ $this->assertEquals(2, count($results));
+ $paths = array();
+ foreach ($results as $result) {
+ $paths[] = $result['path'];
+ }
+ $this->assertContains('/anotherstorage/folder/bar.txt', $paths);
+ $this->assertContains('/bar.txt', $paths);
+
+ $results = $folderView->search('foo');
+ $this->assertEquals(2, count($results));
+ $paths = array();
+ foreach ($results as $result) {
+ $paths[] = $result['path'];
+ }
+ $this->assertContains('/anotherstorage/foo.txt', $paths);
+ $this->assertContains('/anotherstorage/foo.png', $paths);
+
+ $this->assertEquals(6, count($rootView->searchByMime('text')));
+ $this->assertEquals(3, count($folderView->searchByMime('text')));
+ }
+
+ function testWatcher() {
+ $storage1 = $this->getTestStorage();
+ \OC\Files\Filesystem::mount($storage1, array(), '/');
+
+ $rootView = new \OC\Files\View('');
+
+ $cachedData = $rootView->getFileInfo('foo.txt');
+ $this->assertEquals(16, $cachedData['size']);
+
+ $rootView->putFileInfo('foo.txt', array('mtime' => 10));
+ $storage1->file_put_contents('foo.txt', 'foo');
+ clearstatcache();
+
+ $cachedData = $rootView->getFileInfo('foo.txt');
+ $this->assertEquals(3, $cachedData['size']);
+ }
+
+ /**
+ * @param bool $scan
+ * @return \OC\Files\Storage\Storage
+ */
+ private function getTestStorage($scan = true) {
+ $storage = new \OC\Files\Storage\Temporary(array());
+ $textData = "dummy file data\n";
+ $imgData = file_get_contents(\OC::$SERVERROOT . '/core/img/logo.png');
+ $storage->mkdir('folder');
+ $storage->file_put_contents('foo.txt', $textData);
+ $storage->file_put_contents('foo.png', $imgData);
+ $storage->file_put_contents('folder/bar.txt', $textData);
+
+ if ($scan) {
+ $scanner = $storage->getScanner();
+ $scanner->scan('');
+ }
+ $this->storages[] = $storage;
+ return $storage;
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-05-30 09:13:48 +0000