open-dsi
/
nextcloud-server
mirror of https://github.com/nextcloud/server
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Adds NullCache ans NullStorage tests for Lockdown

Browse Source 
Signed-off-by: Roeland Jago Douma <roeland@famdouma.nl>
pull/719/head
Roeland Jago Douma 10 years ago committed by Robin Appelman
parent e5bc80b31d
commit 59d6003f89
No known key found for this signature in database
GPG Key ID: 425003AC385454C5
2 changed files with 402 additions and 0 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 157
      tests/lib/Lockdown/Filesystem/NullCacheTest.php
  2. 245
      tests/lib/Lockdown/Filesystem/NullStorageTest.php

157
tests/lib/Lockdown/Filesystem/NullCacheTest.php
Unescape View File

@ -0,0 +1,157 @@
<?php
/**
* @copyright 2016, Roeland Jago Douma <roeland@famdouma.nl>
*
* @author Roeland Jago Douma <roeland@famdouma.nl>
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program 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 program. If not, see <http://www.gnu.org/licenses/>.
*
*/
namespace Test\Lockdown\Filesystem;
use OC\ForbiddenException;
use OC\Lockdown\Filesystem\NullCache;
use OCP\Constants;
use OCP\Files\Cache\ICache;
use OCP\Files\FileInfo;
class NulLCacheTest extends \Test\TestCase {
/** @var NullCache */
private $cache;
public function setUp() {
parent::setUp();
$this->cache = new NullCache();
}
public function testGetNumericStorageId() {
$this->assertSame(-1, $this->cache->getNumericStorageId());
}
public function testGetEmpty() {
$this->assertNull($this->cache->get('foo'));
}
public function testGet() {
$data = $this->cache->get('');
$this->assertEquals(-1, $data['fileid']);
$this->assertEquals(-1, $data['parent']);
$this->assertEquals('', $data['name']);
$this->assertEquals('', $data['path']);
$this->assertEquals('0', $data['size']);
$this->assertEquals('', $data['etag']);
$this->assertEquals(FileInfo::MIMETYPE_FOLDER, $data['mimetype']);
$this->assertEquals('httpd', $data['mimepart']);
$this->assertEquals(Constants::PERMISSION_READ, $data['permissions']);
}
public function testGetFolderContents() {
$this->assertSame([], $this->cache->getFolderContents('foo'));
}
public function testGetFolderContentsById() {
$this->assertSame([], $this->cache->getFolderContentsById(42));
}
public function testPut() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->cache->put('foo', ['size' => 100]);
}
public function testInsert() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->cache->insert('foo', ['size' => 100]);
}
public function testUpdate() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->cache->update('foo', ['size' => 100]);
}
public function testGetId() {
$this->assertSame(-1, $this->cache->getId('foo'));
}
public function testGetParentId() {
$this->assertSame(-1, $this->cache->getParentId('foo'));
}
public function testInCache() {
$this->assertTrue($this->cache->inCache(''));
$this->assertFalse($this->cache->inCache('foo'));
}
public function testRemove() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->cache->remove('foo');
}
public function testMove() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->cache->move('foo', 'bar');
}
public function testMoveFromCache() {
$sourceCache = $this->createMock(ICache::class);
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->cache->moveFromCache($sourceCache, 'foo', 'bar');
}
public function testGetStatus() {
$this->assertSame(ICache::COMPLETE, $this->cache->getStatus('foo'));
}
public function testSearch() {
$this->assertSame([], $this->cache->search('foo'));
}
public function testSearchByMime() {
$this->assertSame([], $this->cache->searchByMime('foo'));
}
public function testSearchByTag() {
$this->assertSame([], $this->cache->searchByTag('foo', 'user'));
}
public function testGetIncomplete() {
$this->assertSame([], $this->cache->getIncomplete());
}
public function testGetPathById() {
$this->assertSame('', $this->cache->getPathById(42));
}
public function testNormalize() {
$this->assertSame('foo/ bar /', $this->cache->normalize('foo/ bar /'));
}
}

245
tests/lib/Lockdown/Filesystem/NullStorageTest.php
Unescape View File

@ -0,0 +1,245 @@
<?php
/**
* @copyright 2016, Roeland Jago Douma <roeland@famdouma.nl>
*
* @author Roeland Jago Douma <roeland@famdouma.nl>
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program 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 program. If not, see <http://www.gnu.org/licenses/>.
*
*/
namespace Test\Lockdown\Filesystem;
use Icewind\Streams\IteratorDirectory;
use OC\ForbiddenException;
use OC\Lockdown\Filesystem\NullCache;
use OC\Lockdown\Filesystem\NullStorage;
use OCP\Files\Storage;
use Test\TestCase;
class NullStorageTest extends TestCase {
/** @var NullStorage */
private $storage;
public function setUp() {
parent::setUp();
$this->storage = new NullStorage([]);
}
public function testGetId() {
$this->assertSame('null', $this->storage->getId());
}
public function testMkdir() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->storage->mkdir('foo');
}
public function testRmdir() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->storage->rmdir('foo');
}
public function testOpendir() {
$this->assertInstanceOf(IteratorDirectory::class, $this->storage->opendir('foo'));
}
public function testIs_dir() {
$this->assertTrue($this->storage->is_dir(''));
$this->assertFalse($this->storage->is_dir('foo'));
}
public function testIs_file() {
$this->assertFalse($this->storage->is_file('foo'));
}
public function testStat() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->storage->stat('foo');
}
public function testFiletype() {
$this->assertSame('dir', $this->storage->filetype(''));
$this->assertFalse($this->storage->filetype('foo'));
}
public function testFilesize() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->storage->filesize('foo');
}
public function testIsCreatable() {
$this->assertFalse($this->storage->isCreatable('foo'));
}
public function testIsReadable() {
$this->assertTrue($this->storage->isReadable(''));
$this->assertFalse($this->storage->isReadable('foo'));
}
public function testIsUpdatable() {
$this->assertFalse($this->storage->isUpdatable('foo'));
}
public function testIsDeletable() {
$this->assertFalse($this->storage->isDeletable('foo'));
}
public function testIsSharable() {
$this->assertFalse($this->storage->isSharable('foo'));
}
public function testGetPermissions() {
$this->assertNull($this->storage->getPermissions('foo'));
}
public function testFile_exists() {
$this->assertTrue($this->storage->file_exists(''));
$this->assertFalse($this->storage->file_exists('foo'));
}
public function testFilemtime() {
$this->assertFalse($this->storage->isReadable('foo'));
}
public function testFile_get_contents() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->storage->file_get_contents('foo');
}
public function testFile_put_contents() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->storage->file_put_contents('foo', 'bar');
}
public function testUnlink() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->storage->unlink('foo');
}
public function testRename() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->storage->rename('foo', 'bar');
}
public function testCopy() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->storage->copy('foo', 'bar');
}
public function testFopen() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->storage->fopen('foo', 'R');
}
public function testGetMimeType() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->storage->getMimeType('foo');
}
public function testHash() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->storage->hash('md5', 'foo', true);
}
public function testFree_space() {
$this->assertSame(0, $this->storage->free_space('foo'));
}
public function testTouch() {
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->storage->touch('foo');
}
public function testGetLocalFile() {
$this->assertFalse($this->storage->getLocalFile('foo'));
}
public function testHasUpdated() {
$this->assertFalse($this->storage->hasUpdated('foo', 42));
}
public function testGetETag() {
$this->assertSame('', $this->storage->getETag('foo'));
}
public function testIsLocal() {
$this->assertFalse($this->storage->isLocal());
}
public function testGetDirectDownload() {
$this->assertFalse($this->storage->getDirectDownload('foo'));
}
public function testCopyFromStorage() {
$sourceStorage = $this->createMock(Storage::class);
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->storage->copyFromStorage($sourceStorage, 'foo', 'bar');
}
public function testMoveFromStorage() {
$sourceStorage = $this->createMock(Storage::class);
$this->expectException(ForbiddenException::class);
$this->expectExceptionMessage('This request is not allowed to access the filesystem');
$this->storage->moveFromStorage($sourceStorage, 'foo', 'bar');
}
public function testTest() {
$this->assertTrue($this->storage->test());
return true;
}
public function testGetOwner() {
$this->assertNull($this->storage->getOwner('foo'));
}
public function testGetCache() {
$this->assertInstanceOf(NullCache::class, $this->storage->getCache('foo'));
}
}
Write Preview
Loading…
Cancel
Save