2012-10-21 00:12:58 +00:00
|
|
|
|
<?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. */
|
|
|
|
|
|
2012-10-26 10:30:25 +00:00
|
|
|
|
namespace Test\Files;
|
|
|
|
|
|
2014-02-18 15:31:40 +00:00
|
|
|
|
use OC\Files\Cache\Watcher;
|
2015-01-16 12:33:17 +00:00
|
|
|
|
use OC\Files\Storage\Common;
|
2015-03-05 16:22:48 +00:00
|
|
|
|
use OC\Files\Mount\MountPoint;
|
2014-10-14 15:15:46 +00:00
|
|
|
|
use OC\Files\Storage\Temporary;
|
2015-05-05 11:48:49 +00:00
|
|
|
|
use OCP\Lock\ILockingProvider;
|
2014-02-18 15:31:40 +00:00
|
|
|
|
|
2013-02-10 11:44:27 +00:00
|
|
|
|
class TemporaryNoTouch extends \OC\Files\Storage\Temporary {
|
|
|
|
|
public function touch($path, $mtime = null) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-16 12:33:17 +00:00
|
|
|
|
class TemporaryNoCross extends \OC\Files\Storage\Temporary {
|
|
|
|
|
public function copyFromStorage(\OCP\Files\Storage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
|
|
|
|
|
return Common::copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function moveFromStorage(\OCP\Files\Storage $sourceStorage, $sourceInternalPath, $targetInternalPath) {
|
|
|
|
|
return Common::moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
class TemporaryNoLocal extends \OC\Files\Storage\Temporary {
|
|
|
|
|
public function instanceOfStorage($className) {
|
2015-04-22 14:24:25 +00:00
|
|
|
|
if ($className === '\OC\Files\Storage\Local') {
|
2015-01-16 12:33:17 +00:00
|
|
|
|
return false;
|
|
|
|
|
} else {
|
|
|
|
|
return parent::instanceOfStorage($className);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-07 14:23:15 +00:00
|
|
|
|
class View extends \Test\TestCase {
|
2012-10-21 00:12:58 +00:00
|
|
|
|
/**
|
2013-12-12 14:14:44 +00:00
|
|
|
|
* @var \OC\Files\Storage\Storage[] $storages
|
2012-10-21 00:12:58 +00:00
|
|
|
|
*/
|
|
|
|
|
private $storages = array();
|
2014-05-08 13:19:54 +00:00
|
|
|
|
private $user;
|
2012-10-21 00:12:58 +00:00
|
|
|
|
|
2014-11-12 14:54:41 +00:00
|
|
|
|
/** @var \OC\Files\Storage\Storage */
|
2014-06-06 08:41:49 +00:00
|
|
|
|
private $tempStorage;
|
|
|
|
|
|
2014-11-12 14:54:41 +00:00
|
|
|
|
protected function setUp() {
|
|
|
|
|
parent::setUp();
|
|
|
|
|
|
2013-06-26 18:48:54 +00:00
|
|
|
|
\OC_User::clearBackends();
|
|
|
|
|
\OC_User::useBackend(new \OC_User_Dummy());
|
|
|
|
|
|
|
|
|
|
//login
|
|
|
|
|
\OC_User::createUser('test', 'test');
|
2013-08-29 13:25:38 +00:00
|
|
|
|
$this->user = \OC_User::getUser();
|
2013-06-26 18:48:54 +00:00
|
|
|
|
|
2015-04-08 10:03:55 +00:00
|
|
|
|
$this->loginAsUser('test');
|
|
|
|
|
// clear mounts but somehow keep the root storage
|
|
|
|
|
// that was initialized above...
|
2012-10-26 16:07:01 +00:00
|
|
|
|
\OC\Files\Filesystem::clearMounts();
|
2014-06-06 08:41:49 +00:00
|
|
|
|
|
|
|
|
|
$this->tempStorage = null;
|
2012-10-21 00:12:58 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-11-12 14:54:41 +00:00
|
|
|
|
protected function tearDown() {
|
2013-06-26 18:48:54 +00:00
|
|
|
|
\OC_User::setUserId($this->user);
|
2012-10-21 00:12:58 +00:00
|
|
|
|
foreach ($this->storages as $storage) {
|
|
|
|
|
$cache = $storage->getCache();
|
2012-10-28 10:26:31 +00:00
|
|
|
|
$ids = $cache->getAll();
|
2012-10-21 00:12:58 +00:00
|
|
|
|
$cache->clear();
|
|
|
|
|
}
|
2014-06-06 08:41:49 +00:00
|
|
|
|
|
|
|
|
|
if ($this->tempStorage && !\OC_Util::runningOnWindows()) {
|
|
|
|
|
system('rm -rf ' . escapeshellarg($this->tempStorage->getDataDir()));
|
|
|
|
|
}
|
2014-11-12 14:54:41 +00:00
|
|
|
|
|
2015-04-08 10:03:55 +00:00
|
|
|
|
$this->logout();
|
2014-11-12 14:54:41 +00:00
|
|
|
|
parent::tearDown();
|
2012-10-21 00:12:58 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 07:31:22 +00:00
|
|
|
|
/**
|
|
|
|
|
* @medium
|
|
|
|
|
*/
|
2012-10-21 00:12:58 +00:00
|
|
|
|
public function testCacheAPI() {
|
|
|
|
|
$storage1 = $this->getTestStorage();
|
|
|
|
|
$storage2 = $this->getTestStorage();
|
|
|
|
|
$storage3 = $this->getTestStorage();
|
2014-12-02 12:51:36 +00:00
|
|
|
|
$root = $this->getUniqueID('/');
|
2014-06-03 09:34:48 +00:00
|
|
|
|
\OC\Files\Filesystem::mount($storage1, array(), $root . '/');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage2, array(), $root . '/substorage');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage3, array(), $root . '/folder/anotherstorage');
|
2012-10-21 00:12:58 +00:00
|
|
|
|
$textSize = strlen("dummy file data\n");
|
|
|
|
|
$imageSize = filesize(\OC::$SERVERROOT . '/core/img/logo.png');
|
|
|
|
|
$storageSize = $textSize * 2 + $imageSize;
|
|
|
|
|
|
2014-06-03 09:34:48 +00:00
|
|
|
|
$storageInfo = $storage3->getCache()->get('');
|
|
|
|
|
$this->assertEquals($storageSize, $storageInfo['size']);
|
|
|
|
|
|
|
|
|
|
$rootView = new \OC\Files\View($root);
|
2012-10-26 10:30:25 +00:00
|
|
|
|
|
|
|
|
|
$cachedData = $rootView->getFileInfo('/foo.txt');
|
2012-10-21 00:12:58 +00:00
|
|
|
|
$this->assertEquals($textSize, $cachedData['size']);
|
|
|
|
|
$this->assertEquals('text/plain', $cachedData['mimetype']);
|
2013-01-07 00:03:11 +00:00
|
|
|
|
$this->assertNotEquals(-1, $cachedData['permissions']);
|
2012-10-21 00:12:58 +00:00
|
|
|
|
|
2012-10-26 10:30:25 +00:00
|
|
|
|
$cachedData = $rootView->getFileInfo('/');
|
2012-10-21 00:12:58 +00:00
|
|
|
|
$this->assertEquals($storageSize * 3, $cachedData['size']);
|
|
|
|
|
$this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
|
|
|
|
|
|
2013-11-18 16:29:30 +00:00
|
|
|
|
// get cached data excluding mount points
|
|
|
|
|
$cachedData = $rootView->getFileInfo('/', false);
|
|
|
|
|
$this->assertEquals($storageSize, $cachedData['size']);
|
|
|
|
|
$this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
|
|
|
|
|
|
2012-10-26 10:30:25 +00:00
|
|
|
|
$cachedData = $rootView->getFileInfo('/folder');
|
2012-10-21 00:12:58 +00:00
|
|
|
|
$this->assertEquals($storageSize + $textSize, $cachedData['size']);
|
|
|
|
|
$this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
|
|
|
|
|
|
2012-10-26 10:30:25 +00:00
|
|
|
|
$folderData = $rootView->getDirectoryContent('/');
|
2012-10-21 00:12:58 +00:00
|
|
|
|
/**
|
|
|
|
|
* expected entries:
|
2012-11-25 15:08:35 +00:00
|
|
|
|
* folder
|
2012-10-21 00:12:58 +00:00
|
|
|
|
* foo.png
|
|
|
|
|
* foo.txt
|
|
|
|
|
* substorage
|
|
|
|
|
*/
|
|
|
|
|
$this->assertEquals(4, count($folderData));
|
2012-11-25 15:08:35 +00:00
|
|
|
|
$this->assertEquals('folder', $folderData[0]['name']);
|
|
|
|
|
$this->assertEquals('foo.png', $folderData[1]['name']);
|
|
|
|
|
$this->assertEquals('foo.txt', $folderData[2]['name']);
|
2012-10-21 00:12:58 +00:00
|
|
|
|
$this->assertEquals('substorage', $folderData[3]['name']);
|
|
|
|
|
|
2012-11-25 15:08:35 +00:00
|
|
|
|
$this->assertEquals($storageSize + $textSize, $folderData[0]['size']);
|
|
|
|
|
$this->assertEquals($imageSize, $folderData[1]['size']);
|
|
|
|
|
$this->assertEquals($textSize, $folderData[2]['size']);
|
2012-10-21 00:12:58 +00:00
|
|
|
|
$this->assertEquals($storageSize, $folderData[3]['size']);
|
2012-10-26 10:37:49 +00:00
|
|
|
|
|
2012-11-24 22:41:39 +00:00
|
|
|
|
$folderData = $rootView->getDirectoryContent('/substorage');
|
|
|
|
|
/**
|
|
|
|
|
* expected entries:
|
2012-11-25 15:08:35 +00:00
|
|
|
|
* folder
|
2012-11-24 22:41:39 +00:00
|
|
|
|
* foo.png
|
|
|
|
|
* foo.txt
|
|
|
|
|
*/
|
|
|
|
|
$this->assertEquals(3, count($folderData));
|
2012-11-25 15:08:35 +00:00
|
|
|
|
$this->assertEquals('folder', $folderData[0]['name']);
|
|
|
|
|
$this->assertEquals('foo.png', $folderData[1]['name']);
|
|
|
|
|
$this->assertEquals('foo.txt', $folderData[2]['name']);
|
2012-11-24 22:41:39 +00:00
|
|
|
|
|
2014-06-03 09:34:48 +00:00
|
|
|
|
$folderView = new \OC\Files\View($root . '/folder');
|
2012-10-26 10:37:49 +00:00
|
|
|
|
$this->assertEquals($rootView->getFileInfo('/folder'), $folderView->getFileInfo('/'));
|
2012-10-26 10:43:23 +00:00
|
|
|
|
|
|
|
|
|
$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);
|
2012-12-11 00:06:21 +00:00
|
|
|
|
|
|
|
|
|
$this->assertFalse($rootView->getFileInfo('/non/existing'));
|
|
|
|
|
$this->assertEquals(array(), $rootView->getDirectoryContent('/non/existing'));
|
2012-10-21 00:12:58 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 07:31:22 +00:00
|
|
|
|
/**
|
|
|
|
|
* @medium
|
|
|
|
|
*/
|
2013-01-26 23:13:16 +00:00
|
|
|
|
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));
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 07:31:22 +00:00
|
|
|
|
/**
|
|
|
|
|
* @medium
|
|
|
|
|
*/
|
2013-01-22 19:57:15 +00:00
|
|
|
|
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));
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-15 02:20:50 +00:00
|
|
|
|
function testCacheIncompleteFolder() {
|
|
|
|
|
$storage1 = $this->getTestStorage(false);
|
2014-10-16 13:17:36 +00:00
|
|
|
|
\OC\Files\Filesystem::clearMounts();
|
|
|
|
|
\OC\Files\Filesystem::mount($storage1, array(), '/incomplete');
|
|
|
|
|
$rootView = new \OC\Files\View('/incomplete');
|
2012-12-15 02:20:50 +00:00
|
|
|
|
|
|
|
|
|
$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));
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-21 20:05:29 +00:00
|
|
|
|
public function testAutoScan() {
|
|
|
|
|
$storage1 = $this->getTestStorage(false);
|
|
|
|
|
$storage2 = $this->getTestStorage(false);
|
2012-10-26 16:07:01 +00:00
|
|
|
|
\OC\Files\Filesystem::mount($storage1, array(), '/');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage2, array(), '/substorage');
|
2012-10-21 20:05:29 +00:00
|
|
|
|
$textSize = strlen("dummy file data\n");
|
|
|
|
|
|
2012-10-26 10:30:25 +00:00
|
|
|
|
$rootView = new \OC\Files\View('');
|
|
|
|
|
|
|
|
|
|
$cachedData = $rootView->getFileInfo('/');
|
2012-10-21 20:05:29 +00:00
|
|
|
|
$this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
|
|
|
|
|
$this->assertEquals(-1, $cachedData['size']);
|
|
|
|
|
|
2012-10-26 10:30:25 +00:00
|
|
|
|
$folderData = $rootView->getDirectoryContent('/substorage/folder');
|
2012-10-21 20:05:29 +00:00
|
|
|
|
$this->assertEquals('text/plain', $folderData[0]['mimetype']);
|
|
|
|
|
$this->assertEquals($textSize, $folderData[0]['size']);
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 07:31:22 +00:00
|
|
|
|
/**
|
|
|
|
|
* @medium
|
|
|
|
|
*/
|
2012-10-26 11:23:15 +00:00
|
|
|
|
function testSearch() {
|
|
|
|
|
$storage1 = $this->getTestStorage();
|
|
|
|
|
$storage2 = $this->getTestStorage();
|
|
|
|
|
$storage3 = $this->getTestStorage();
|
2012-10-26 16:07:01 +00:00
|
|
|
|
\OC\Files\Filesystem::mount($storage1, array(), '/');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage2, array(), '/substorage');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage3, array(), '/folder/anotherstorage');
|
2012-10-26 11:23:15 +00:00
|
|
|
|
|
|
|
|
|
$rootView = new \OC\Files\View('');
|
|
|
|
|
|
|
|
|
|
$results = $rootView->search('foo');
|
|
|
|
|
$this->assertEquals(6, count($results));
|
|
|
|
|
$paths = array();
|
|
|
|
|
foreach ($results as $result) {
|
2012-10-26 16:07:01 +00:00
|
|
|
|
$this->assertEquals($result['path'], \OC\Files\Filesystem::normalizePath($result['path']));
|
2012-10-26 11:23:15 +00:00
|
|
|
|
$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);
|
2012-10-27 08:34:25 +00:00
|
|
|
|
|
|
|
|
|
$this->assertEquals(6, count($rootView->searchByMime('text')));
|
|
|
|
|
$this->assertEquals(3, count($folderView->searchByMime('text')));
|
2012-10-26 11:23:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 07:31:22 +00:00
|
|
|
|
/**
|
|
|
|
|
* @medium
|
|
|
|
|
*/
|
2012-10-28 10:43:45 +00:00
|
|
|
|
function testWatcher() {
|
|
|
|
|
$storage1 = $this->getTestStorage();
|
|
|
|
|
\OC\Files\Filesystem::mount($storage1, array(), '/');
|
2014-02-18 15:31:40 +00:00
|
|
|
|
$storage1->getWatcher()->setPolicy(Watcher::CHECK_ALWAYS);
|
2012-10-28 10:43:45 +00:00
|
|
|
|
|
|
|
|
|
$rootView = new \OC\Files\View('');
|
|
|
|
|
|
|
|
|
|
$cachedData = $rootView->getFileInfo('foo.txt');
|
|
|
|
|
$this->assertEquals(16, $cachedData['size']);
|
|
|
|
|
|
2013-02-10 11:27:35 +00:00
|
|
|
|
$rootView->putFileInfo('foo.txt', array('storage_mtime' => 10));
|
2012-10-28 10:43:45 +00:00
|
|
|
|
$storage1->file_put_contents('foo.txt', 'foo');
|
|
|
|
|
clearstatcache();
|
|
|
|
|
|
|
|
|
|
$cachedData = $rootView->getFileInfo('foo.txt');
|
|
|
|
|
$this->assertEquals(3, $cachedData['size']);
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 07:31:22 +00:00
|
|
|
|
/**
|
|
|
|
|
* @medium
|
|
|
|
|
*/
|
2015-01-16 12:33:17 +00:00
|
|
|
|
function testCopyBetweenStorageNoCross() {
|
|
|
|
|
$storage1 = $this->getTestStorage(true, '\Test\Files\TemporaryNoCross');
|
|
|
|
|
$storage2 = $this->getTestStorage(true, '\Test\Files\TemporaryNoCross');
|
|
|
|
|
$this->copyBetweenStorages($storage1, $storage2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @medium
|
|
|
|
|
*/
|
|
|
|
|
function testCopyBetweenStorageCross() {
|
2013-05-19 18:20:46 +00:00
|
|
|
|
$storage1 = $this->getTestStorage();
|
|
|
|
|
$storage2 = $this->getTestStorage();
|
2015-01-16 12:33:17 +00:00
|
|
|
|
$this->copyBetweenStorages($storage1, $storage2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @medium
|
|
|
|
|
*/
|
|
|
|
|
function testCopyBetweenStorageCrossNonLocal() {
|
|
|
|
|
$storage1 = $this->getTestStorage(true, '\Test\Files\TemporaryNoLocal');
|
|
|
|
|
$storage2 = $this->getTestStorage(true, '\Test\Files\TemporaryNoLocal');
|
|
|
|
|
$this->copyBetweenStorages($storage1, $storage2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function copyBetweenStorages($storage1, $storage2) {
|
2013-05-19 18:20:46 +00:00
|
|
|
|
\OC\Files\Filesystem::mount($storage1, array(), '/');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage2, array(), '/substorage');
|
|
|
|
|
|
|
|
|
|
$rootView = new \OC\Files\View('');
|
2013-05-19 19:04:41 +00:00
|
|
|
|
$rootView->mkdir('substorage/emptyfolder');
|
2013-05-19 18:20:46 +00:00
|
|
|
|
$rootView->copy('substorage', 'anotherfolder');
|
|
|
|
|
$this->assertTrue($rootView->is_dir('/anotherfolder'));
|
|
|
|
|
$this->assertTrue($rootView->is_dir('/substorage'));
|
2013-05-19 19:04:41 +00:00
|
|
|
|
$this->assertTrue($rootView->is_dir('/anotherfolder/emptyfolder'));
|
|
|
|
|
$this->assertTrue($rootView->is_dir('/substorage/emptyfolder'));
|
2013-05-19 18:20:46 +00:00
|
|
|
|
$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'));
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 07:31:22 +00:00
|
|
|
|
/**
|
|
|
|
|
* @medium
|
|
|
|
|
*/
|
2015-01-16 12:33:17 +00:00
|
|
|
|
function testMoveBetweenStorageNoCross() {
|
|
|
|
|
$storage1 = $this->getTestStorage(true, '\Test\Files\TemporaryNoCross');
|
|
|
|
|
$storage2 = $this->getTestStorage(true, '\Test\Files\TemporaryNoCross');
|
|
|
|
|
$this->moveBetweenStorages($storage1, $storage2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @medium
|
|
|
|
|
*/
|
|
|
|
|
function testMoveBetweenStorageCross() {
|
2013-05-19 18:20:46 +00:00
|
|
|
|
$storage1 = $this->getTestStorage();
|
|
|
|
|
$storage2 = $this->getTestStorage();
|
2015-01-16 12:33:17 +00:00
|
|
|
|
$this->moveBetweenStorages($storage1, $storage2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @medium
|
|
|
|
|
*/
|
|
|
|
|
function testMoveBetweenStorageCrossNonLocal() {
|
|
|
|
|
$storage1 = $this->getTestStorage(true, '\Test\Files\TemporaryNoLocal');
|
|
|
|
|
$storage2 = $this->getTestStorage(true, '\Test\Files\TemporaryNoLocal');
|
|
|
|
|
$this->moveBetweenStorages($storage1, $storage2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function moveBetweenStorages($storage1, $storage2) {
|
2013-05-19 18:20:46 +00:00
|
|
|
|
\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'));
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-08 12:17:36 +00:00
|
|
|
|
/**
|
|
|
|
|
* @medium
|
|
|
|
|
*/
|
|
|
|
|
function testUnlink() {
|
|
|
|
|
$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->file_put_contents('/foo.txt', 'asd');
|
|
|
|
|
$rootView->file_put_contents('/substorage/bar.txt', 'asd');
|
|
|
|
|
|
|
|
|
|
$this->assertTrue($rootView->file_exists('foo.txt'));
|
|
|
|
|
$this->assertTrue($rootView->file_exists('substorage/bar.txt'));
|
|
|
|
|
|
|
|
|
|
$this->assertTrue($rootView->unlink('foo.txt'));
|
|
|
|
|
$this->assertTrue($rootView->unlink('substorage/bar.txt'));
|
|
|
|
|
|
|
|
|
|
$this->assertFalse($rootView->file_exists('foo.txt'));
|
|
|
|
|
$this->assertFalse($rootView->file_exists('substorage/bar.txt'));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @medium
|
|
|
|
|
*/
|
|
|
|
|
function testUnlinkRootMustFail() {
|
|
|
|
|
$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->file_put_contents('/foo.txt', 'asd');
|
|
|
|
|
$rootView->file_put_contents('/substorage/bar.txt', 'asd');
|
|
|
|
|
|
|
|
|
|
$this->assertFalse($rootView->unlink(''));
|
|
|
|
|
$this->assertFalse($rootView->unlink('/'));
|
|
|
|
|
$this->assertFalse($rootView->unlink('substorage'));
|
|
|
|
|
$this->assertFalse($rootView->unlink('/substorage'));
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 07:31:22 +00:00
|
|
|
|
/**
|
|
|
|
|
* @medium
|
|
|
|
|
*/
|
2013-02-10 11:44:27 +00:00
|
|
|
|
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');
|
2014-08-04 14:17:11 +00:00
|
|
|
|
$this->assertGreaterThanOrEqual($oldCachedData['mtime'], $cachedData['mtime']);
|
2013-02-10 11:44:27 +00:00
|
|
|
|
$this->assertEquals($cachedData['storage_mtime'], $cachedData['mtime']);
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-29 13:25:38 +00:00
|
|
|
|
/**
|
|
|
|
|
* @medium
|
|
|
|
|
*/
|
|
|
|
|
function testViewHooks() {
|
|
|
|
|
$storage1 = $this->getTestStorage();
|
|
|
|
|
$storage2 = $this->getTestStorage();
|
|
|
|
|
$defaultRoot = \OC\Files\Filesystem::getRoot();
|
|
|
|
|
\OC\Files\Filesystem::mount($storage1, array(), '/');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage2, array(), $defaultRoot . '/substorage');
|
|
|
|
|
\OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHook');
|
|
|
|
|
|
|
|
|
|
$rootView = new \OC\Files\View('');
|
|
|
|
|
$subView = new \OC\Files\View($defaultRoot . '/substorage');
|
|
|
|
|
$this->hookPath = null;
|
|
|
|
|
|
|
|
|
|
$rootView->file_put_contents('/foo.txt', 'asd');
|
|
|
|
|
$this->assertNull($this->hookPath);
|
|
|
|
|
|
|
|
|
|
$subView->file_put_contents('/foo.txt', 'asd');
|
|
|
|
|
$this->assertEquals('/substorage/foo.txt', $this->hookPath);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private $hookPath;
|
|
|
|
|
|
2014-04-28 08:49:35 +00:00
|
|
|
|
public function dummyHook($params) {
|
2013-08-29 13:25:38 +00:00
|
|
|
|
$this->hookPath = $params['path'];
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-21 23:23:18 +00:00
|
|
|
|
public function testSearchNotOutsideView() {
|
|
|
|
|
$storage1 = $this->getTestStorage();
|
|
|
|
|
\OC\Files\Filesystem::mount($storage1, array(), '/');
|
|
|
|
|
$storage1->rename('folder', 'foo');
|
|
|
|
|
$scanner = $storage1->getScanner();
|
|
|
|
|
$scanner->scan('');
|
|
|
|
|
|
|
|
|
|
$view = new \OC\Files\View('/foo');
|
|
|
|
|
|
|
|
|
|
$result = $view->search('.txt');
|
|
|
|
|
$this->assertCount(1, $result);
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-21 00:12:58 +00:00
|
|
|
|
/**
|
2012-10-21 20:05:29 +00:00
|
|
|
|
* @param bool $scan
|
2013-09-21 23:23:18 +00:00
|
|
|
|
* @param string $class
|
2012-10-26 10:30:25 +00:00
|
|
|
|
* @return \OC\Files\Storage\Storage
|
2012-10-21 00:12:58 +00:00
|
|
|
|
*/
|
2013-02-10 11:44:27 +00:00
|
|
|
|
private function getTestStorage($scan = true, $class = '\OC\Files\Storage\Temporary') {
|
|
|
|
|
/**
|
|
|
|
|
* @var \OC\Files\Storage\Storage $storage
|
|
|
|
|
*/
|
|
|
|
|
$storage = new $class(array());
|
2012-10-21 00:12:58 +00:00
|
|
|
|
$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);
|
|
|
|
|
|
2012-10-21 20:05:29 +00:00
|
|
|
|
if ($scan) {
|
|
|
|
|
$scanner = $storage->getScanner();
|
|
|
|
|
$scanner->scan('');
|
|
|
|
|
}
|
2012-10-21 00:12:58 +00:00
|
|
|
|
$this->storages[] = $storage;
|
|
|
|
|
return $storage;
|
|
|
|
|
}
|
2013-10-09 18:46:43 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @medium
|
|
|
|
|
*/
|
|
|
|
|
function testViewHooksIfRootStartsTheSame() {
|
|
|
|
|
$storage1 = $this->getTestStorage();
|
|
|
|
|
$storage2 = $this->getTestStorage();
|
|
|
|
|
$defaultRoot = \OC\Files\Filesystem::getRoot();
|
|
|
|
|
\OC\Files\Filesystem::mount($storage1, array(), '/');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage2, array(), $defaultRoot . '_substorage');
|
|
|
|
|
\OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHook');
|
|
|
|
|
|
|
|
|
|
$subView = new \OC\Files\View($defaultRoot . '_substorage');
|
|
|
|
|
$this->hookPath = null;
|
|
|
|
|
|
|
|
|
|
$subView->file_put_contents('/foo.txt', 'asd');
|
|
|
|
|
$this->assertNull($this->hookPath);
|
|
|
|
|
}
|
2013-10-10 09:34:30 +00:00
|
|
|
|
|
2014-04-28 08:49:35 +00:00
|
|
|
|
private $hookWritePath;
|
|
|
|
|
private $hookCreatePath;
|
|
|
|
|
private $hookUpdatePath;
|
|
|
|
|
|
|
|
|
|
public function dummyHookWrite($params) {
|
|
|
|
|
$this->hookWritePath = $params['path'];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function dummyHookUpdate($params) {
|
|
|
|
|
$this->hookUpdatePath = $params['path'];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function dummyHookCreate($params) {
|
|
|
|
|
$this->hookCreatePath = $params['path'];
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-09 18:34:18 +00:00
|
|
|
|
public function testEditNoCreateHook() {
|
|
|
|
|
$storage1 = $this->getTestStorage();
|
|
|
|
|
$storage2 = $this->getTestStorage();
|
|
|
|
|
$defaultRoot = \OC\Files\Filesystem::getRoot();
|
|
|
|
|
\OC\Files\Filesystem::mount($storage1, array(), '/');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage2, array(), $defaultRoot);
|
2014-04-28 08:49:35 +00:00
|
|
|
|
\OC_Hook::connect('OC_Filesystem', 'post_create', $this, 'dummyHookCreate');
|
|
|
|
|
\OC_Hook::connect('OC_Filesystem', 'post_update', $this, 'dummyHookUpdate');
|
|
|
|
|
\OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHookWrite');
|
2013-10-09 18:34:18 +00:00
|
|
|
|
|
|
|
|
|
$view = new \OC\Files\View($defaultRoot);
|
2014-04-28 08:49:35 +00:00
|
|
|
|
$this->hookWritePath = $this->hookUpdatePath = $this->hookCreatePath = null;
|
2013-10-09 18:34:18 +00:00
|
|
|
|
|
|
|
|
|
$view->file_put_contents('/asd.txt', 'foo');
|
2014-04-28 08:49:35 +00:00
|
|
|
|
$this->assertEquals('/asd.txt', $this->hookCreatePath);
|
|
|
|
|
$this->assertNull($this->hookUpdatePath);
|
|
|
|
|
$this->assertEquals('/asd.txt', $this->hookWritePath);
|
|
|
|
|
|
|
|
|
|
$this->hookWritePath = $this->hookUpdatePath = $this->hookCreatePath = null;
|
2013-10-09 18:34:18 +00:00
|
|
|
|
|
|
|
|
|
$view->file_put_contents('/asd.txt', 'foo');
|
2014-04-28 08:49:35 +00:00
|
|
|
|
$this->assertNull($this->hookCreatePath);
|
|
|
|
|
$this->assertEquals('/asd.txt', $this->hookUpdatePath);
|
|
|
|
|
$this->assertEquals('/asd.txt', $this->hookWritePath);
|
|
|
|
|
|
|
|
|
|
\OC_Hook::clear('OC_Filesystem', 'post_create');
|
|
|
|
|
\OC_Hook::clear('OC_Filesystem', 'post_update');
|
|
|
|
|
\OC_Hook::clear('OC_Filesystem', 'post_write');
|
2013-10-09 18:34:18 +00:00
|
|
|
|
}
|
2013-10-10 14:06:26 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @dataProvider resolvePathTestProvider
|
|
|
|
|
*/
|
|
|
|
|
public function testResolvePath($expected, $pathToTest) {
|
|
|
|
|
$storage1 = $this->getTestStorage();
|
|
|
|
|
\OC\Files\Filesystem::mount($storage1, array(), '/');
|
|
|
|
|
|
|
|
|
|
$view = new \OC\Files\View('');
|
|
|
|
|
|
|
|
|
|
$result = $view->resolvePath($pathToTest);
|
|
|
|
|
$this->assertEquals($expected, $result[1]);
|
|
|
|
|
|
|
|
|
|
$exists = $view->file_exists($pathToTest);
|
|
|
|
|
$this->assertTrue($exists);
|
|
|
|
|
|
|
|
|
|
$exists = $view->file_exists($result[1]);
|
|
|
|
|
$this->assertTrue($exists);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function resolvePathTestProvider() {
|
|
|
|
|
return array(
|
|
|
|
|
array('foo.txt', 'foo.txt'),
|
|
|
|
|
array('foo.txt', '/foo.txt'),
|
|
|
|
|
array('folder', 'folder'),
|
|
|
|
|
array('folder', '/folder'),
|
|
|
|
|
array('folder', 'folder/'),
|
|
|
|
|
array('folder', '/folder/'),
|
|
|
|
|
array('folder/bar.txt', 'folder/bar.txt'),
|
|
|
|
|
array('folder/bar.txt', '/folder/bar.txt'),
|
|
|
|
|
array('', ''),
|
|
|
|
|
array('', '/'),
|
|
|
|
|
);
|
|
|
|
|
}
|
2013-12-12 12:43:55 +00:00
|
|
|
|
|
|
|
|
|
public function testUTF8Names() {
|
|
|
|
|
$names = array('虚', '和知しゃ和で', 'regular ascii', 'sɨˈrɪlɪk', 'ѨѬ', 'أنا أحب القراءة كثيرا');
|
|
|
|
|
|
|
|
|
|
$storage = new \OC\Files\Storage\Temporary(array());
|
|
|
|
|
\OC\Files\Filesystem::mount($storage, array(), '/');
|
|
|
|
|
|
|
|
|
|
$rootView = new \OC\Files\View('');
|
|
|
|
|
foreach ($names as $name) {
|
|
|
|
|
$rootView->file_put_contents('/' . $name, 'dummy content');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$list = $rootView->getDirectoryContent('/');
|
|
|
|
|
|
|
|
|
|
$this->assertCount(count($names), $list);
|
|
|
|
|
foreach ($list as $item) {
|
|
|
|
|
$this->assertContains($item['name'], $names);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$cache = $storage->getCache();
|
|
|
|
|
$scanner = $storage->getScanner();
|
|
|
|
|
$scanner->scan('');
|
|
|
|
|
|
|
|
|
|
$list = $cache->getFolderContents('');
|
|
|
|
|
|
|
|
|
|
$this->assertCount(count($names), $list);
|
|
|
|
|
foreach ($list as $item) {
|
|
|
|
|
$this->assertContains($item['name'], $names);
|
|
|
|
|
}
|
|
|
|
|
}
|
2014-01-14 14:11:41 +00:00
|
|
|
|
|
2014-12-10 11:20:30 +00:00
|
|
|
|
public function xtestLongPath() {
|
2014-05-08 13:19:54 +00:00
|
|
|
|
|
|
|
|
|
$storage = new \OC\Files\Storage\Temporary(array());
|
|
|
|
|
\OC\Files\Filesystem::mount($storage, array(), '/');
|
|
|
|
|
|
|
|
|
|
$rootView = new \OC\Files\View('');
|
|
|
|
|
|
|
|
|
|
$longPath = '';
|
2014-09-23 15:17:31 +00:00
|
|
|
|
$ds = DIRECTORY_SEPARATOR;
|
|
|
|
|
/*
|
|
|
|
|
* 4096 is the maximum path length in file_cache.path in *nix
|
|
|
|
|
* 1024 is the max path length in mac
|
|
|
|
|
* 228 is the max path length in windows
|
|
|
|
|
*/
|
2014-05-08 13:19:54 +00:00
|
|
|
|
$folderName = 'abcdefghijklmnopqrstuvwxyz012345678901234567890123456789';
|
2014-09-23 15:17:31 +00:00
|
|
|
|
$tmpdirLength = strlen(\OC_Helper::tmpFolder());
|
|
|
|
|
if (\OC_Util::runningOnWindows()) {
|
2014-11-10 10:01:43 +00:00
|
|
|
|
$this->markTestSkipped('[Windows] ');
|
2014-09-23 15:17:31 +00:00
|
|
|
|
$depth = ((260 - $tmpdirLength) / 57);
|
2015-01-23 14:11:27 +00:00
|
|
|
|
} elseif (\OC_Util::runningOnMac()) {
|
2014-09-23 15:17:31 +00:00
|
|
|
|
$depth = ((1024 - $tmpdirLength) / 57);
|
|
|
|
|
} else {
|
|
|
|
|
$depth = ((4000 - $tmpdirLength) / 57);
|
|
|
|
|
}
|
2014-06-03 09:34:48 +00:00
|
|
|
|
foreach (range(0, $depth - 1) as $i) {
|
2014-09-23 15:17:31 +00:00
|
|
|
|
$longPath .= $ds . $folderName;
|
2014-05-08 13:19:54 +00:00
|
|
|
|
$result = $rootView->mkdir($longPath);
|
|
|
|
|
$this->assertTrue($result, "mkdir failed on $i - path length: " . strlen($longPath));
|
|
|
|
|
|
2014-09-23 15:17:31 +00:00
|
|
|
|
$result = $rootView->file_put_contents($longPath . "{$ds}test.txt", 'lorem');
|
2014-05-08 13:19:54 +00:00
|
|
|
|
$this->assertEquals(5, $result, "file_put_contents failed on $i");
|
|
|
|
|
|
|
|
|
|
$this->assertTrue($rootView->file_exists($longPath));
|
2014-09-23 15:17:31 +00:00
|
|
|
|
$this->assertTrue($rootView->file_exists($longPath . "{$ds}test.txt"));
|
2014-05-08 13:19:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$cache = $storage->getCache();
|
|
|
|
|
$scanner = $storage->getScanner();
|
|
|
|
|
$scanner->scan('');
|
|
|
|
|
|
|
|
|
|
$longPath = $folderName;
|
2014-06-03 09:34:48 +00:00
|
|
|
|
foreach (range(0, $depth - 1) as $i) {
|
2014-05-08 13:19:54 +00:00
|
|
|
|
$cachedFolder = $cache->get($longPath);
|
|
|
|
|
$this->assertTrue(is_array($cachedFolder), "No cache entry for folder at $i");
|
|
|
|
|
$this->assertEquals($folderName, $cachedFolder['name'], "Wrong cache entry for folder at $i");
|
|
|
|
|
|
|
|
|
|
$cachedFile = $cache->get($longPath . '/test.txt');
|
|
|
|
|
$this->assertTrue(is_array($cachedFile), "No cache entry for file at $i");
|
|
|
|
|
$this->assertEquals('test.txt', $cachedFile['name'], "Wrong cache entry for file at $i");
|
|
|
|
|
|
2014-09-23 15:17:31 +00:00
|
|
|
|
$longPath .= $ds . $folderName;
|
2014-05-08 13:19:54 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-14 14:11:41 +00:00
|
|
|
|
public function testTouchNotSupported() {
|
|
|
|
|
$storage = new TemporaryNoTouch(array());
|
|
|
|
|
$scanner = $storage->getScanner();
|
|
|
|
|
\OC\Files\Filesystem::mount($storage, array(), '/test/');
|
|
|
|
|
$past = time() - 100;
|
|
|
|
|
$storage->file_put_contents('test', 'foobar');
|
|
|
|
|
$scanner->scan('');
|
|
|
|
|
$view = new \OC\Files\View('');
|
|
|
|
|
$info = $view->getFileInfo('/test/test');
|
|
|
|
|
|
|
|
|
|
$view->touch('/test/test', $past);
|
|
|
|
|
$scanner->scanFile('test', \OC\Files\Cache\Scanner::REUSE_ETAG);
|
|
|
|
|
|
|
|
|
|
$info2 = $view->getFileInfo('/test/test');
|
2014-02-27 08:39:34 +00:00
|
|
|
|
$this->assertSame($info['etag'], $info2['etag']);
|
2014-01-14 14:11:41 +00:00
|
|
|
|
}
|
2014-05-13 12:17:51 +00:00
|
|
|
|
|
2014-10-14 15:15:46 +00:00
|
|
|
|
public function testWatcherEtagCrossStorage() {
|
|
|
|
|
$storage1 = new Temporary(array());
|
|
|
|
|
$storage2 = new Temporary(array());
|
|
|
|
|
$scanner1 = $storage1->getScanner();
|
|
|
|
|
$scanner2 = $storage2->getScanner();
|
|
|
|
|
$storage1->mkdir('sub');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage1, array(), '/test/');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage2, array(), '/test/sub/storage');
|
|
|
|
|
|
|
|
|
|
$past = time() - 100;
|
|
|
|
|
$storage2->file_put_contents('test.txt', 'foobar');
|
|
|
|
|
$scanner1->scan('');
|
|
|
|
|
$scanner2->scan('');
|
|
|
|
|
$view = new \OC\Files\View('');
|
|
|
|
|
|
|
|
|
|
$storage2->getWatcher('')->setPolicy(Watcher::CHECK_ALWAYS);
|
|
|
|
|
|
|
|
|
|
$oldFileInfo = $view->getFileInfo('/test/sub/storage/test.txt');
|
|
|
|
|
$oldFolderInfo = $view->getFileInfo('/test');
|
|
|
|
|
|
|
|
|
|
$storage2->getCache()->update($oldFileInfo->getId(), array(
|
|
|
|
|
'storage_mtime' => $past
|
|
|
|
|
));
|
|
|
|
|
|
|
|
|
|
$view->getFileInfo('/test/sub/storage/test.txt');
|
|
|
|
|
$newFolderInfo = $view->getFileInfo('/test');
|
|
|
|
|
|
|
|
|
|
$this->assertNotEquals($newFolderInfo->getEtag(), $oldFolderInfo->getEtag());
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-13 12:17:51 +00:00
|
|
|
|
/**
|
|
|
|
|
* @dataProvider absolutePathProvider
|
|
|
|
|
*/
|
|
|
|
|
public function testGetAbsolutePath($expectedPath, $relativePath) {
|
|
|
|
|
$view = new \OC\Files\View('/files');
|
|
|
|
|
$this->assertEquals($expectedPath, $view->getAbsolutePath($relativePath));
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-13 12:59:28 +00:00
|
|
|
|
public function testPartFileInfo() {
|
|
|
|
|
$storage = new Temporary(array());
|
|
|
|
|
$scanner = $storage->getScanner();
|
|
|
|
|
\OC\Files\Filesystem::mount($storage, array(), '/test/');
|
|
|
|
|
$storage->file_put_contents('test.part', 'foobar');
|
|
|
|
|
$scanner->scan('');
|
|
|
|
|
$view = new \OC\Files\View('/test');
|
|
|
|
|
$info = $view->getFileInfo('test.part');
|
|
|
|
|
|
|
|
|
|
$this->assertInstanceOf('\OCP\Files\FileInfo', $info);
|
|
|
|
|
$this->assertNull($info->getId());
|
|
|
|
|
$this->assertEquals(6, $info->getSize());
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-13 12:17:51 +00:00
|
|
|
|
function absolutePathProvider() {
|
|
|
|
|
return array(
|
|
|
|
|
array('/files/', ''),
|
|
|
|
|
array('/files/0', '0'),
|
2014-05-13 20:01:11 +00:00
|
|
|
|
array('/files/false', 'false'),
|
|
|
|
|
array('/files/true', 'true'),
|
2014-05-13 12:17:51 +00:00
|
|
|
|
array('/files/', '/'),
|
|
|
|
|
array('/files/test', 'test'),
|
|
|
|
|
array('/files/test', '/test'),
|
|
|
|
|
);
|
|
|
|
|
}
|
2014-05-08 13:19:54 +00:00
|
|
|
|
|
2015-02-04 11:07:16 +00:00
|
|
|
|
/**
|
|
|
|
|
* @dataProvider relativePathProvider
|
|
|
|
|
*/
|
|
|
|
|
function testGetRelativePath($absolutePath, $expectedPath) {
|
|
|
|
|
$view = new \OC\Files\View('/files');
|
|
|
|
|
// simulate a external storage mount point which has a trailing slash
|
|
|
|
|
$view->chroot('/files/');
|
|
|
|
|
$this->assertEquals($expectedPath, $view->getRelativePath($absolutePath));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function relativePathProvider() {
|
|
|
|
|
return array(
|
|
|
|
|
array('/files/', '/'),
|
|
|
|
|
array('/files', '/'),
|
|
|
|
|
array('/files/0', '0'),
|
|
|
|
|
array('/files/false', 'false'),
|
|
|
|
|
array('/files/true', 'true'),
|
|
|
|
|
array('/files/test', 'test'),
|
|
|
|
|
array('/files/test/foo', 'test/foo'),
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-26 16:48:09 +00:00
|
|
|
|
public function testFileView() {
|
|
|
|
|
$storage = new Temporary(array());
|
|
|
|
|
$scanner = $storage->getScanner();
|
|
|
|
|
$storage->file_put_contents('foo.txt', 'bar');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage, array(), '/test/');
|
|
|
|
|
$scanner->scan('');
|
|
|
|
|
$view = new \OC\Files\View('/test/foo.txt');
|
|
|
|
|
|
|
|
|
|
$this->assertEquals('bar', $view->file_get_contents(''));
|
|
|
|
|
$fh = tmpfile();
|
|
|
|
|
fwrite($fh, 'foo');
|
|
|
|
|
rewind($fh);
|
|
|
|
|
$view->file_put_contents('', $fh);
|
|
|
|
|
$this->assertEquals('foo', $view->file_get_contents(''));
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-08 13:19:54 +00:00
|
|
|
|
/**
|
|
|
|
|
* @dataProvider tooLongPathDataProvider
|
|
|
|
|
* @expectedException \OCP\Files\InvalidPathException
|
|
|
|
|
*/
|
2014-06-03 09:34:48 +00:00
|
|
|
|
public function testTooLongPath($operation, $param0 = null) {
|
2014-05-08 13:19:54 +00:00
|
|
|
|
|
|
|
|
|
$longPath = '';
|
|
|
|
|
// 4000 is the maximum path length in file_cache.path
|
|
|
|
|
$folderName = 'abcdefghijklmnopqrstuvwxyz012345678901234567890123456789';
|
2014-06-03 09:34:48 +00:00
|
|
|
|
$depth = (4000 / 57);
|
|
|
|
|
foreach (range(0, $depth + 1) as $i) {
|
|
|
|
|
$longPath .= '/' . $folderName;
|
2014-05-08 13:19:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$storage = new \OC\Files\Storage\Temporary(array());
|
2014-06-06 08:41:49 +00:00
|
|
|
|
$this->tempStorage = $storage; // for later hard cleanup
|
2014-05-08 13:19:54 +00:00
|
|
|
|
\OC\Files\Filesystem::mount($storage, array(), '/');
|
|
|
|
|
|
|
|
|
|
$rootView = new \OC\Files\View('');
|
|
|
|
|
|
|
|
|
|
if ($param0 === '@0') {
|
|
|
|
|
$param0 = $longPath;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ($operation === 'hash') {
|
|
|
|
|
$param0 = $longPath;
|
|
|
|
|
$longPath = 'md5';
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
call_user_func(array($rootView, $operation), $longPath, $param0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function tooLongPathDataProvider() {
|
|
|
|
|
return array(
|
|
|
|
|
array('getAbsolutePath'),
|
|
|
|
|
array('getRelativePath'),
|
|
|
|
|
array('getMountPoint'),
|
|
|
|
|
array('resolvePath'),
|
|
|
|
|
array('getLocalFile'),
|
|
|
|
|
array('getLocalFolder'),
|
|
|
|
|
array('mkdir'),
|
|
|
|
|
array('rmdir'),
|
|
|
|
|
array('opendir'),
|
|
|
|
|
array('is_dir'),
|
|
|
|
|
array('is_file'),
|
|
|
|
|
array('stat'),
|
|
|
|
|
array('filetype'),
|
|
|
|
|
array('filesize'),
|
|
|
|
|
array('readfile'),
|
|
|
|
|
array('isCreatable'),
|
|
|
|
|
array('isReadable'),
|
|
|
|
|
array('isUpdatable'),
|
|
|
|
|
array('isDeletable'),
|
|
|
|
|
array('isSharable'),
|
|
|
|
|
array('file_exists'),
|
|
|
|
|
array('filemtime'),
|
|
|
|
|
array('touch'),
|
|
|
|
|
array('file_get_contents'),
|
|
|
|
|
array('unlink'),
|
|
|
|
|
array('deleteAll'),
|
|
|
|
|
array('toTmpFile'),
|
|
|
|
|
array('getMimeType'),
|
|
|
|
|
array('free_space'),
|
|
|
|
|
array('getFileInfo'),
|
|
|
|
|
array('getDirectoryContent'),
|
|
|
|
|
array('getOwner'),
|
|
|
|
|
array('getETag'),
|
|
|
|
|
array('file_put_contents', 'ipsum'),
|
|
|
|
|
array('rename', '@0'),
|
|
|
|
|
array('copy', '@0'),
|
|
|
|
|
array('fopen', 'r'),
|
|
|
|
|
array('fromTmpFile', '@0'),
|
|
|
|
|
array('hash'),
|
|
|
|
|
array('hasUpdated', 0),
|
|
|
|
|
array('putFileInfo', array()),
|
|
|
|
|
);
|
|
|
|
|
}
|
2015-01-23 14:11:27 +00:00
|
|
|
|
|
|
|
|
|
public function testRenameCrossStoragePreserveMtime() {
|
|
|
|
|
$storage1 = new Temporary(array());
|
|
|
|
|
$storage2 = new Temporary(array());
|
|
|
|
|
$scanner1 = $storage1->getScanner();
|
|
|
|
|
$scanner2 = $storage2->getScanner();
|
|
|
|
|
$storage1->mkdir('sub');
|
|
|
|
|
$storage1->mkdir('foo');
|
|
|
|
|
$storage1->file_put_contents('foo.txt', 'asd');
|
|
|
|
|
$storage1->file_put_contents('foo/bar.txt', 'asd');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage1, array(), '/test/');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage2, array(), '/test/sub/storage');
|
|
|
|
|
|
|
|
|
|
$view = new \OC\Files\View('');
|
|
|
|
|
$time = time() - 200;
|
|
|
|
|
$view->touch('/test/foo.txt', $time);
|
|
|
|
|
$view->touch('/test/foo', $time);
|
|
|
|
|
$view->touch('/test/foo/bar.txt', $time);
|
|
|
|
|
|
|
|
|
|
$view->rename('/test/foo.txt', '/test/sub/storage/foo.txt');
|
|
|
|
|
|
|
|
|
|
$this->assertEquals($time, $view->filemtime('/test/sub/storage/foo.txt'));
|
|
|
|
|
|
|
|
|
|
$view->rename('/test/foo', '/test/sub/storage/foo');
|
|
|
|
|
|
|
|
|
|
$this->assertEquals($time, $view->filemtime('/test/sub/storage/foo/bar.txt'));
|
|
|
|
|
}
|
2015-01-20 11:59:57 +00:00
|
|
|
|
|
2015-02-25 11:44:44 +00:00
|
|
|
|
public function testRenameFailDeleteTargetKeepSource() {
|
|
|
|
|
$this->doTestCopyRenameFail('rename');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testCopyFailDeleteTargetKeepSource() {
|
|
|
|
|
$this->doTestCopyRenameFail('copy');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private function doTestCopyRenameFail($operation) {
|
|
|
|
|
$storage1 = new Temporary(array());
|
2015-03-05 10:49:31 +00:00
|
|
|
|
/** @var \PHPUnit_Framework_MockObject_MockObject | \OC\Files\Storage\Temporary $storage2 */
|
|
|
|
|
$storage2 = $this->getMockBuilder('\Test\Files\TemporaryNoCross')
|
|
|
|
|
->setConstructorArgs([[]])
|
|
|
|
|
->setMethods(['fopen'])
|
|
|
|
|
->getMock();
|
|
|
|
|
|
|
|
|
|
$storage2->expects($this->any())
|
|
|
|
|
->method('fopen')
|
2015-04-22 14:24:25 +00:00
|
|
|
|
->will($this->returnCallback(function ($path, $mode) use ($storage2) {
|
2015-03-05 10:49:31 +00:00
|
|
|
|
$source = fopen($storage2->getSourcePath($path), $mode);
|
|
|
|
|
return \OC\Files\Stream\Quota::wrap($source, 9);
|
|
|
|
|
}));
|
|
|
|
|
|
2015-02-25 11:44:44 +00:00
|
|
|
|
$storage1->mkdir('sub');
|
|
|
|
|
$storage1->file_put_contents('foo.txt', '0123456789ABCDEFGH');
|
|
|
|
|
$storage1->mkdir('dirtomove');
|
|
|
|
|
$storage1->file_put_contents('dirtomove/indir1.txt', '0123456'); // fits
|
|
|
|
|
$storage1->file_put_contents('dirtomove/indir2.txt', '0123456789ABCDEFGH'); // doesn't fit
|
|
|
|
|
$storage2->file_put_contents('existing.txt', '0123');
|
|
|
|
|
$storage1->getScanner()->scan('');
|
|
|
|
|
$storage2->getScanner()->scan('');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage1, array(), '/test/');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage2, array(), '/test/sub/storage');
|
|
|
|
|
|
|
|
|
|
// move file
|
|
|
|
|
$view = new \OC\Files\View('');
|
|
|
|
|
$this->assertTrue($storage1->file_exists('foo.txt'));
|
|
|
|
|
$this->assertFalse($storage2->file_exists('foo.txt'));
|
|
|
|
|
$this->assertFalse($view->$operation('/test/foo.txt', '/test/sub/storage/foo.txt'));
|
|
|
|
|
$this->assertFalse($storage2->file_exists('foo.txt'));
|
|
|
|
|
$this->assertFalse($storage2->getCache()->get('foo.txt'));
|
|
|
|
|
$this->assertTrue($storage1->file_exists('foo.txt'));
|
|
|
|
|
|
|
|
|
|
// if target exists, it will be deleted too
|
|
|
|
|
$this->assertFalse($view->$operation('/test/foo.txt', '/test/sub/storage/existing.txt'));
|
|
|
|
|
$this->assertFalse($storage2->file_exists('existing.txt'));
|
|
|
|
|
$this->assertFalse($storage2->getCache()->get('existing.txt'));
|
|
|
|
|
$this->assertTrue($storage1->file_exists('foo.txt'));
|
|
|
|
|
|
|
|
|
|
// move folder
|
|
|
|
|
$this->assertFalse($view->$operation('/test/dirtomove/', '/test/sub/storage/dirtomove/'));
|
|
|
|
|
// since the move failed, the full source tree is kept
|
|
|
|
|
$this->assertTrue($storage1->file_exists('dirtomove/indir1.txt'));
|
|
|
|
|
$this->assertTrue($storage1->file_exists('dirtomove/indir2.txt'));
|
2015-03-05 10:49:31 +00:00
|
|
|
|
// second file not moved/copied
|
2015-02-25 11:44:44 +00:00
|
|
|
|
$this->assertFalse($storage2->file_exists('dirtomove/indir2.txt'));
|
|
|
|
|
$this->assertFalse($storage2->getCache()->get('dirtomove/indir2.txt'));
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-20 11:59:57 +00:00
|
|
|
|
public function testDeleteFailKeepCache() {
|
|
|
|
|
/**
|
|
|
|
|
* @var \PHPUnit_Framework_MockObject_MockObject | \OC\Files\Storage\Temporary $storage
|
|
|
|
|
*/
|
|
|
|
|
$storage = $this->getMockBuilder('\OC\Files\Storage\Temporary')
|
|
|
|
|
->setConstructorArgs(array(array()))
|
|
|
|
|
->setMethods(array('unlink'))
|
|
|
|
|
->getMock();
|
|
|
|
|
$storage->expects($this->once())
|
|
|
|
|
->method('unlink')
|
|
|
|
|
->will($this->returnValue(false));
|
|
|
|
|
$scanner = $storage->getScanner();
|
|
|
|
|
$cache = $storage->getCache();
|
|
|
|
|
$storage->file_put_contents('foo.txt', 'asd');
|
|
|
|
|
$scanner->scan('');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage, array(), '/test/');
|
|
|
|
|
|
|
|
|
|
$view = new \OC\Files\View('/test');
|
|
|
|
|
|
|
|
|
|
$this->assertFalse($view->unlink('foo.txt'));
|
|
|
|
|
$this->assertTrue($cache->inCache('foo.txt'));
|
|
|
|
|
}
|
2015-02-18 15:01:24 +00:00
|
|
|
|
|
|
|
|
|
function directoryTraversalProvider() {
|
|
|
|
|
return [
|
|
|
|
|
['../test/'],
|
|
|
|
|
['..\\test\\my/../folder'],
|
|
|
|
|
['/test/my/../foo\\'],
|
|
|
|
|
];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @dataProvider directoryTraversalProvider
|
|
|
|
|
* @expectedException \Exception
|
|
|
|
|
* @param string $root
|
|
|
|
|
*/
|
|
|
|
|
public function testConstructDirectoryTraversalException($root) {
|
|
|
|
|
new \OC\Files\View($root);
|
|
|
|
|
}
|
2015-02-27 13:26:52 +00:00
|
|
|
|
|
|
|
|
|
public function testRenameOverWrite() {
|
|
|
|
|
$storage = new Temporary(array());
|
|
|
|
|
$scanner = $storage->getScanner();
|
|
|
|
|
$storage->mkdir('sub');
|
|
|
|
|
$storage->mkdir('foo');
|
|
|
|
|
$storage->file_put_contents('foo.txt', 'asd');
|
|
|
|
|
$storage->file_put_contents('foo/bar.txt', 'asd');
|
|
|
|
|
$scanner->scan('');
|
|
|
|
|
\OC\Files\Filesystem::mount($storage, array(), '/test/');
|
|
|
|
|
$view = new \OC\Files\View('');
|
|
|
|
|
$this->assertTrue($view->rename('/test/foo.txt', '/test/foo/bar.txt'));
|
|
|
|
|
}
|
2015-03-05 16:22:48 +00:00
|
|
|
|
|
|
|
|
|
public function testSetMountOptionsInStorage() {
|
2015-03-16 13:13:56 +00:00
|
|
|
|
$mount = new MountPoint('\OC\Files\Storage\Temporary', '/asd/', [[]], \OC\Files\Filesystem::getLoader(), ['foo' => 'bar']);
|
2015-03-05 16:31:35 +00:00
|
|
|
|
\OC\Files\Filesystem::getMountManager()->addMount($mount);
|
2015-03-05 16:22:48 +00:00
|
|
|
|
/** @var \OC\Files\Storage\Common $storage */
|
|
|
|
|
$storage = $mount->getStorage();
|
|
|
|
|
$this->assertEquals($storage->getMountOption('foo'), 'bar');
|
|
|
|
|
}
|
2015-03-05 16:27:10 +00:00
|
|
|
|
|
|
|
|
|
public function testSetMountOptionsWatcherPolicy() {
|
2015-03-16 13:13:56 +00:00
|
|
|
|
$mount = new MountPoint('\OC\Files\Storage\Temporary', '/asd/', [[]], \OC\Files\Filesystem::getLoader(), ['filesystem_check_changes' => Watcher::CHECK_NEVER]);
|
2015-03-05 16:31:35 +00:00
|
|
|
|
\OC\Files\Filesystem::getMountManager()->addMount($mount);
|
2015-03-05 16:27:10 +00:00
|
|
|
|
/** @var \OC\Files\Storage\Common $storage */
|
|
|
|
|
$storage = $mount->getStorage();
|
|
|
|
|
$watcher = $storage->getWatcher();
|
|
|
|
|
$this->assertEquals(Watcher::CHECK_NEVER, $watcher->getPolicy());
|
|
|
|
|
}
|
2015-04-22 14:24:25 +00:00
|
|
|
|
|
|
|
|
|
public function testGetAbsolutePathOnNull() {
|
|
|
|
|
$view = new \OC\Files\View();
|
|
|
|
|
$this->assertNull($view->getAbsolutePath(null));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testGetRelativePathOnNull() {
|
|
|
|
|
$view = new \OC\Files\View();
|
|
|
|
|
$this->assertNull($view->getRelativePath(null));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @expectedException \InvalidArgumentException
|
|
|
|
|
*/
|
|
|
|
|
public function testNullAsRoot() {
|
|
|
|
|
new \OC\Files\View(null);
|
|
|
|
|
}
|
2015-05-05 11:48:49 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* e.g. reading from a folder that's being renamed
|
|
|
|
|
*
|
|
|
|
|
* @expectedException \OCP\Lock\LockedException
|
2015-06-12 09:41:05 +00:00
|
|
|
|
*
|
|
|
|
|
* @dataProvider dataLockPaths
|
|
|
|
|
*
|
|
|
|
|
* @param string $rootPath
|
|
|
|
|
* @param string $pathPrefix
|
2015-05-05 11:48:49 +00:00
|
|
|
|
*/
|
2015-06-12 09:41:05 +00:00
|
|
|
|
public function testReadFromWriteLockedPath($rootPath, $pathPrefix) {
|
|
|
|
|
$rootPath = str_replace('{folder}', 'files', $rootPath);
|
|
|
|
|
$pathPrefix = str_replace('{folder}', 'files', $pathPrefix);
|
|
|
|
|
|
|
|
|
|
$view = new \OC\Files\View($rootPath);
|
2015-05-05 11:48:49 +00:00
|
|
|
|
$storage = new Temporary(array());
|
2015-05-11 15:22:39 +00:00
|
|
|
|
\OC\Files\Filesystem::mount($storage, [], '/');
|
2015-06-12 09:41:05 +00:00
|
|
|
|
$this->assertTrue($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
|
|
|
|
|
$view->lockFile($pathPrefix . '/foo/bar/asd', ILockingProvider::LOCK_SHARED);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Reading from a files_encryption folder that's being renamed
|
|
|
|
|
*
|
|
|
|
|
* @dataProvider dataLockPaths
|
|
|
|
|
*
|
|
|
|
|
* @param string $rootPath
|
|
|
|
|
* @param string $pathPrefix
|
|
|
|
|
*/
|
|
|
|
|
public function testReadFromWriteUnlockablePath($rootPath, $pathPrefix) {
|
|
|
|
|
$rootPath = str_replace('{folder}', 'files_encryption', $rootPath);
|
|
|
|
|
$pathPrefix = str_replace('{folder}', 'files_encryption', $pathPrefix);
|
|
|
|
|
|
|
|
|
|
$view = new \OC\Files\View($rootPath);
|
|
|
|
|
$storage = new Temporary(array());
|
|
|
|
|
\OC\Files\Filesystem::mount($storage, [], '/');
|
|
|
|
|
$this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
|
|
|
|
|
$this->assertFalse($view->lockFile($pathPrefix . '/foo/bar/asd', ILockingProvider::LOCK_SHARED));
|
2015-05-05 11:48:49 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* e.g. writing a file that's being downloaded
|
|
|
|
|
*
|
|
|
|
|
* @expectedException \OCP\Lock\LockedException
|
2015-06-12 09:41:05 +00:00
|
|
|
|
*
|
|
|
|
|
* @dataProvider dataLockPaths
|
|
|
|
|
*
|
|
|
|
|
* @param string $rootPath
|
|
|
|
|
* @param string $pathPrefix
|
2015-05-05 11:48:49 +00:00
|
|
|
|
*/
|
2015-06-12 09:41:05 +00:00
|
|
|
|
public function testWriteToReadLockedFile($rootPath, $pathPrefix) {
|
|
|
|
|
$rootPath = str_replace('{folder}', 'files', $rootPath);
|
|
|
|
|
$pathPrefix = str_replace('{folder}', 'files', $pathPrefix);
|
|
|
|
|
|
|
|
|
|
$view = new \OC\Files\View($rootPath);
|
2015-05-05 11:48:49 +00:00
|
|
|
|
$storage = new Temporary(array());
|
2015-05-11 15:22:39 +00:00
|
|
|
|
\OC\Files\Filesystem::mount($storage, [], '/');
|
2015-06-12 09:41:05 +00:00
|
|
|
|
$this->assertTrue($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_SHARED));
|
|
|
|
|
$view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Writing a file that's being downloaded
|
|
|
|
|
*
|
|
|
|
|
* @dataProvider dataLockPaths
|
|
|
|
|
*
|
|
|
|
|
* @param string $rootPath
|
|
|
|
|
* @param string $pathPrefix
|
|
|
|
|
*/
|
|
|
|
|
public function testWriteToReadUnlockableFile($rootPath, $pathPrefix) {
|
|
|
|
|
$rootPath = str_replace('{folder}', 'files_encryption', $rootPath);
|
|
|
|
|
$pathPrefix = str_replace('{folder}', 'files_encryption', $pathPrefix);
|
|
|
|
|
|
|
|
|
|
$view = new \OC\Files\View($rootPath);
|
|
|
|
|
$storage = new Temporary(array());
|
|
|
|
|
\OC\Files\Filesystem::mount($storage, [], '/');
|
|
|
|
|
$this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_SHARED));
|
|
|
|
|
$this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function dataLockPaths() {
|
|
|
|
|
return [
|
|
|
|
|
['/testuser/{folder}', ''],
|
|
|
|
|
['/testuser', '/{folder}'],
|
|
|
|
|
['', '/testuser/{folder}'],
|
|
|
|
|
];
|
2015-05-05 11:48:49 +00:00
|
|
|
|
}
|
2015-06-11 16:32:15 +00:00
|
|
|
|
|
|
|
|
|
public function pathRelativeToFilesProvider() {
|
|
|
|
|
return [
|
|
|
|
|
['admin/files', ''],
|
|
|
|
|
['admin/files/x', 'x'],
|
|
|
|
|
['/admin/files', ''],
|
|
|
|
|
['/admin/files/sub', 'sub'],
|
|
|
|
|
['/admin/files/sub/', 'sub'],
|
|
|
|
|
['/admin/files/sub/sub2', 'sub/sub2'],
|
|
|
|
|
['//admin//files/sub//sub2', 'sub/sub2'],
|
|
|
|
|
];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @dataProvider pathRelativeToFilesProvider
|
|
|
|
|
*/
|
|
|
|
|
public function testGetPathRelativeToFiles($path, $expectedPath) {
|
|
|
|
|
$view = new \OC\Files\View();
|
|
|
|
|
$this->assertEquals($expectedPath, $view->getPathRelativeToFiles($path));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function pathRelativeToFilesProviderExceptionCases() {
|
|
|
|
|
return [
|
|
|
|
|
[''],
|
|
|
|
|
['x'],
|
|
|
|
|
['files'],
|
|
|
|
|
['/files'],
|
|
|
|
|
['/admin/files_versions/abc'],
|
|
|
|
|
];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @dataProvider pathRelativeToFilesProviderExceptionCases
|
|
|
|
|
* @expectedException \InvalidArgumentException
|
|
|
|
|
*/
|
|
|
|
|
public function testGetPathRelativeToFilesWithInvalidArgument($path) {
|
|
|
|
|
$view = new \OC\Files\View();
|
|
|
|
|
$view->getPathRelativeToFiles($path);
|
|
|
|
|
}
|
2012-10-21 00:12:58 +00:00
|
|
|
|
}
|