nextcloud/tests/lib/Files/Storage/Storage.php

649 lines
23 KiB
PHP
Raw Normal View History

<?php
/**
2012-10-11 21:30:27 +04:00
* 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;
use OC\Files\Cache\Watcher;
use OCP\Files\Storage\IWriteStreamStorage;
abstract class Storage extends \Test\TestCase {
/**
2012-09-07 20:30:48 +04:00
* @var \OC\Files\Storage\Storage instance
*/
protected $instance;
protected $waitDelay = 0;
/**
* Sleep for the number of seconds specified in the
* $waitDelay attribute
*/
protected function wait() {
if ($this->waitDelay > 0) {
sleep($this->waitDelay);
}
}
/**
* the root folder of the storage should always exist, be readable and be recognized as a directory
*/
2012-09-07 17:22:01 +04:00
public function testRoot() {
2012-10-11 21:30:27 +04:00
$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');
2013-01-24 19:47:17 +04:00
$this->assertEquals('dir', $this->instance->filetype('/'));
2012-10-11 21:30:27 +04:00
2012-10-12 00:54:39 +04:00
//without this, any further testing would be useless, not an actual requirement for filestorage though
2012-10-11 21:30:27 +04:00
$this->assertTrue($this->instance->isUpdatable('/'), 'Root folder is not writable');
}
2012-10-11 21:30:27 +04:00
/**
* Check that the test() function works
*/
public function testTestFunction() {
$this->assertTrue($this->instance->test());
}
/**
* @dataProvider directoryProvider
*/
public function testDirectories($directory) {
$this->assertFalse($this->instance->file_exists('/' . $directory));
2012-10-11 21:30:27 +04:00
$this->assertTrue($this->instance->mkdir('/' . $directory));
2012-10-11 21:30:27 +04:00
$this->assertTrue($this->instance->file_exists('/' . $directory));
$this->assertTrue($this->instance->is_dir('/' . $directory));
$this->assertFalse($this->instance->is_file('/' . $directory));
$this->assertEquals('dir', $this->instance->filetype('/' . $directory));
$this->assertEquals(0, $this->instance->filesize('/' . $directory));
$this->assertTrue($this->instance->isReadable('/' . $directory));
$this->assertTrue($this->instance->isUpdatable('/' . $directory));
2012-10-11 21:30:27 +04:00
$dh = $this->instance->opendir('/');
$content = array();
while ($file = readdir($dh)) {
if ($file != '.' and $file != '..') {
$content[] = $file;
}
}
$this->assertEquals(array($directory), $content);
2012-10-11 21:30:27 +04:00
$this->assertFalse($this->instance->mkdir('/' . $directory)); //can't create existing folders
$this->assertTrue($this->instance->rmdir('/' . $directory));
2012-10-11 21:30:27 +04:00
$this->wait();
$this->assertFalse($this->instance->file_exists('/' . $directory));
2012-10-11 21:30:27 +04:00
$this->assertFalse($this->instance->rmdir('/' . $directory)); //can't remove non existing folders
2012-10-11 21:30:27 +04:00
$dh = $this->instance->opendir('/');
$content = array();
while ($file = readdir($dh)) {
if ($file != '.' and $file != '..') {
$content[] = $file;
}
}
2013-01-24 19:47:17 +04:00
$this->assertEquals(array(), $content);
}
public function fileNameProvider() {
return [
['file.txt'],
[' file.txt'],
['folder .txt'],
['file with space.txt'],
['spéciäl fäile'],
['test single\'quote.txt'],
];
}
public function directoryProvider() {
return [
['folder'],
[' folder'],
['folder '],
['folder with space'],
['spéciäl földer'],
['test single\'quote'],
];
}
function loremFileProvider() {
$root = \OC::$SERVERROOT . '/tests/data/';
return array(
// small file
array($root . 'lorem.txt'),
// bigger file (> 8 KB which is the standard PHP block size)
array($root . 'lorem-big.txt')
);
}
/**
* test the various uses of file_get_contents and file_put_contents
*
* @dataProvider loremFileProvider
*/
public function testGetPutContents($sourceFile) {
2012-10-11 21:30:27 +04:00
$sourceText = file_get_contents($sourceFile);
//fill a file with string data
2012-10-11 21:30:27 +04:00
$this->instance->file_put_contents('/lorem.txt', $sourceText);
2012-05-18 03:54:02 +04:00
$this->assertFalse($this->instance->is_dir('/lorem.txt'));
2013-01-24 19:47:17 +04:00
$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
2012-10-11 21:30:27 +04:00
$this->instance->file_put_contents('/lorem.txt', '');
2013-01-24 19:47:17 +04:00
$this->assertEquals('', $this->instance->file_get_contents('/lorem.txt'), 'file not emptied');
}
2012-10-11 21:30:27 +04:00
/**
* test various known mimetypes
*/
2012-09-07 17:22:01 +04:00
public function testMimeType() {
2013-01-24 19:47:17 +04:00
$this->assertEquals('httpd/unix-directory', $this->instance->getMimeType('/'));
$this->assertEquals(false, $this->instance->getMimeType('/non/existing/file'));
2012-10-11 21:30:27 +04:00
2012-10-12 00:54:39 +04:00
$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
2012-10-11 21:30:27 +04:00
$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile, 'r'));
2013-01-24 19:47:17 +04:00
$this->assertEquals('text/plain', $this->instance->getMimeType('/lorem.txt'));
2012-10-11 21:30:27 +04:00
2015-05-21 23:40:26 +03:00
$pngFile = \OC::$SERVERROOT . '/tests/data/desktopapp.png';
$this->instance->file_put_contents('/desktopapp.png', file_get_contents($pngFile, 'r'));
$this->assertEquals('image/png', $this->instance->getMimeType('/desktopapp.png'));
2012-10-11 21:30:27 +04:00
2015-05-21 23:40:26 +03:00
$svgFile = \OC::$SERVERROOT . '/tests/data/desktopapp.svg';
$this->instance->file_put_contents('/desktopapp.svg', file_get_contents($svgFile, 'r'));
$this->assertEquals('image/svg+xml', $this->instance->getMimeType('/desktopapp.svg'));
}
2012-10-11 21:30:27 +04:00
2014-08-14 17:46:14 +04:00
public function copyAndMoveProvider() {
return [
['/source.txt', '/target.txt'],
['/source.txt', '/target with space.txt'],
['/source with space.txt', '/target.txt'],
['/source with space.txt', '/target with space.txt'],
['/source.txt', '/tärgét.txt'],
['/sòurcē.txt', '/target.txt'],
['/sòurcē.txt', '/tärgét.txt'],
['/single \' quote.txt', '/tar\'get.txt'],
];
2014-08-14 17:46:14 +04:00
}
public function initSourceAndTarget($source, $target = null) {
2014-08-14 17:46:14 +04:00
$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
$this->instance->file_put_contents($source, file_get_contents($textFile));
if ($target) {
$testContents = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
$this->instance->file_put_contents($target, $testContents);
}
}
public function assertSameAsLorem($file) {
2012-10-12 00:54:39 +04:00
$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
2014-08-14 17:46:14 +04:00
$this->assertEquals(
file_get_contents($textFile),
$this->instance->file_get_contents($file),
'Expected ' . $file . ' to be a copy of ' . $textFile
2014-08-14 17:46:14 +04:00
);
}
/**
* @dataProvider copyAndMoveProvider
*/
public function testCopy($source, $target) {
$this->initSourceAndTarget($source);
$this->instance->copy($source, $target);
$this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
2014-08-14 17:46:14 +04:00
$this->assertSameAsLorem($target);
$this->assertTrue($this->instance->file_exists($source), $source . ' was deleted');
2014-08-14 17:46:14 +04:00
}
/**
* @dataProvider copyAndMoveProvider
*/
public function testMove($source, $target) {
$this->initSourceAndTarget($source);
$this->instance->rename($source, $target);
2012-10-11 21:30:27 +04:00
$this->wait();
$this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
$this->assertFalse($this->instance->file_exists($source), $source . ' still exists');
2014-08-14 17:46:14 +04:00
$this->assertSameAsLorem($target);
}
/**
* @dataProvider copyAndMoveProvider
*/
public function testCopyOverwrite($source, $target) {
$this->initSourceAndTarget($source, $target);
2014-08-14 17:46:14 +04:00
$this->instance->copy($source, $target);
$this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
$this->assertTrue($this->instance->file_exists($source), $source . ' was deleted');
2014-08-14 17:46:14 +04:00
$this->assertSameAsLorem($target);
$this->assertSameAsLorem($source);
}
/**
* @dataProvider copyAndMoveProvider
*/
public function testMoveOverwrite($source, $target) {
$this->initSourceAndTarget($source, $target);
$this->instance->rename($source, $target);
$this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
$this->assertFalse($this->instance->file_exists($source), $source . ' still exists');
2014-08-14 17:46:14 +04:00
$this->assertSameAsLorem($target);
2012-02-27 15:20:47 +04:00
}
2012-10-11 21:30:27 +04:00
2012-09-07 17:22:01 +04:00
public function testLocal() {
2012-10-12 00:54:39 +04:00
$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
2012-10-11 21:30:27 +04:00
$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
$localFile = $this->instance->getLocalFile('/lorem.txt');
2012-02-28 15:06:34 +04:00
$this->assertTrue(file_exists($localFile));
$this->assertEquals(file_get_contents($textFile), file_get_contents($localFile));
2012-10-11 21:30:27 +04:00
2012-08-19 04:30:33 +04:00
$this->instance->mkdir('/folder');
2012-10-11 21:30:27 +04:00
$this->instance->file_put_contents('/folder/lorem.txt', file_get_contents($textFile));
$this->instance->file_put_contents('/folder/bar.txt', 'asd');
2012-08-19 04:30:33 +04:00
$this->instance->mkdir('/folder/recursive');
2012-10-11 21:30:27 +04:00
$this->instance->file_put_contents('/folder/recursive/file.txt', 'foo');
// test below require to use instance->getLocalFile because the physical storage might be different
$localFile = $this->instance->getLocalFile('/folder/lorem.txt');
$this->assertTrue(file_exists($localFile));
$this->assertEquals(file_get_contents($localFile), file_get_contents($textFile));
$localFile = $this->instance->getLocalFile('/folder/bar.txt');
$this->assertTrue(file_exists($localFile));
$this->assertEquals(file_get_contents($localFile), 'asd');
$localFile = $this->instance->getLocalFile('/folder/recursive/file.txt');
$this->assertTrue(file_exists($localFile));
$this->assertEquals(file_get_contents($localFile), 'foo');
2012-02-28 15:06:34 +04:00
}
2012-03-01 02:47:53 +04:00
2012-09-07 17:22:01 +04:00
public function testStat() {
2012-10-12 00:54:39 +04:00
$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
2012-10-11 21:30:27 +04:00
$ctimeStart = time();
$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
$this->assertTrue($this->instance->isReadable('/lorem.txt'));
2012-10-11 21:30:27 +04:00
$ctimeEnd = time();
$mTime = $this->instance->filemtime('/lorem.txt');
2013-07-08 17:03:55 +04:00
$this->assertTrue($this->instance->hasUpdated('/lorem.txt', $ctimeStart - 5));
$this->assertTrue($this->instance->hasUpdated('/', $ctimeStart - 5));
2012-10-11 21:30:27 +04:00
// check that ($ctimeStart - 5) <= $mTime <= ($ctimeEnd + 1)
$this->assertGreaterThanOrEqual(($ctimeStart - 5), $mTime);
$this->assertLessThanOrEqual(($ctimeEnd + 1), $mTime);
2013-01-24 19:47:17 +04:00
$this->assertEquals(filesize($textFile), $this->instance->filesize('/lorem.txt'));
2012-10-11 21:30:27 +04:00
$stat = $this->instance->stat('/lorem.txt');
2013-07-17 01:04:07 +04:00
//only size and mtime are required in the result
2013-01-24 19:47:17 +04:00
$this->assertEquals($stat['size'], $this->instance->filesize('/lorem.txt'));
$this->assertEquals($stat['mtime'], $mTime);
2012-10-11 21:30:27 +04:00
if ($this->instance->touch('/lorem.txt', 100) !== false) {
2012-10-11 21:30:27 +04:00
$mTime = $this->instance->filemtime('/lorem.txt');
$this->assertEquals($mTime, 100);
}
2012-10-11 21:30:27 +04:00
$mtimeStart = time();
2012-06-15 18:43:24 +04:00
$this->instance->unlink('/lorem.txt');
2013-07-08 17:03:55 +04:00
$this->assertTrue($this->instance->hasUpdated('/', $mtimeStart - 5));
2012-03-01 02:47:53 +04:00
}
/**
* Test whether checkUpdate properly returns false when there was
* no change.
*/
public function testCheckUpdate() {
if ($this->instance instanceof \OC\Files\Storage\Wrapper\Wrapper) {
$this->markTestSkipped('Cannot test update check on wrappers');
}
$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
$watcher = $this->instance->getWatcher();
$watcher->setPolicy(Watcher::CHECK_ALWAYS);
$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
$this->assertTrue($watcher->checkUpdate('/lorem.txt'), 'Update detected');
$this->assertFalse($watcher->checkUpdate('/lorem.txt'), 'No update');
}
public function testUnlink() {
$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
$this->assertTrue($this->instance->file_exists('/lorem.txt'));
$this->assertTrue($this->instance->unlink('/lorem.txt'));
$this->wait();
$this->assertFalse($this->instance->file_exists('/lorem.txt'));
}
/**
* @dataProvider fileNameProvider
*/
public function testFOpen($fileName) {
2012-10-12 00:54:39 +04:00
$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
$fh = @$this->instance->fopen($fileName, 'r');
if ($fh) {
fclose($fh);
}
$this->assertFalse($fh);
$this->assertFalse($this->instance->file_exists($fileName));
$fh = $this->instance->fopen($fileName, 'w');
fwrite($fh, file_get_contents($textFile));
fclose($fh);
$this->assertTrue($this->instance->file_exists($fileName));
$fh = $this->instance->fopen($fileName, 'r');
$content = stream_get_contents($fh);
2013-01-24 19:47:17 +04:00
$this->assertEquals(file_get_contents($textFile), $content);
}
2013-04-10 15:45:36 +04:00
2013-06-06 22:47:20 +04:00
public function testTouchCreateFile() {
$this->assertFalse($this->instance->file_exists('touch'));
// returns true on success
$this->assertTrue($this->instance->touch('touch'));
$this->assertTrue($this->instance->file_exists('touch'));
2013-04-10 15:45:36 +04:00
}
2013-06-06 22:47:20 +04:00
public function testRecursiveRmdir() {
$this->instance->mkdir('folder');
$this->instance->mkdir('folder/bar');
$this->wait();
2013-06-06 22:47:20 +04:00
$this->instance->file_put_contents('folder/asd.txt', 'foobar');
$this->instance->file_put_contents('folder/bar/foo.txt', 'asd');
$this->assertTrue($this->instance->rmdir('folder'));
$this->wait();
$this->assertFalse($this->instance->file_exists('folder/asd.txt'));
$this->assertFalse($this->instance->file_exists('folder/bar/foo.txt'));
$this->assertFalse($this->instance->file_exists('folder/bar'));
$this->assertFalse($this->instance->file_exists('folder'));
}
public function testRmdirEmptyFolder() {
$this->assertTrue($this->instance->mkdir('empty'));
$this->wait();
$this->assertTrue($this->instance->rmdir('empty'));
$this->assertFalse($this->instance->file_exists('empty'));
}
public function testRecursiveUnlink() {
$this->instance->mkdir('folder');
$this->instance->mkdir('folder/bar');
$this->instance->file_put_contents('folder/asd.txt', 'foobar');
$this->instance->file_put_contents('folder/bar/foo.txt', 'asd');
$this->assertTrue($this->instance->unlink('folder'));
$this->wait();
2013-06-06 22:47:20 +04:00
$this->assertFalse($this->instance->file_exists('folder/asd.txt'));
$this->assertFalse($this->instance->file_exists('folder/bar/foo.txt'));
$this->assertFalse($this->instance->file_exists('folder/bar'));
$this->assertFalse($this->instance->file_exists('folder'));
}
public function hashProvider() {
return array(
array('Foobar', 'md5'),
array('Foobar', 'sha1'),
array('Foobar', 'sha256'),
);
}
/**
* @dataProvider hashProvider
*/
public function testHash($data, $type) {
$this->instance->file_put_contents('hash.txt', $data);
$this->assertEquals(hash($type, $data), $this->instance->hash($type, 'hash.txt'));
$this->assertEquals(hash($type, $data, true), $this->instance->hash($type, 'hash.txt', true));
}
public function testHashInFileName() {
$this->instance->file_put_contents('#test.txt', 'data');
$this->assertEquals('data', $this->instance->file_get_contents('#test.txt'));
$this->instance->mkdir('#foo');
$this->instance->file_put_contents('#foo/test.txt', 'data');
$this->assertEquals('data', $this->instance->file_get_contents('#foo/test.txt'));
$dh = $this->instance->opendir('#foo');
$content = array();
while ($file = readdir($dh)) {
if ($file != '.' and $file != '..') {
$content[] = $file;
}
}
$this->assertEquals(array('test.txt'), $content);
}
public function testCopyOverWriteFile() {
$this->instance->file_put_contents('target.txt', 'foo');
$this->instance->file_put_contents('source.txt', 'bar');
$this->instance->copy('source.txt', 'target.txt');
$this->assertEquals('bar', $this->instance->file_get_contents('target.txt'));
}
public function testRenameOverWriteFile() {
$this->instance->file_put_contents('target.txt', 'foo');
$this->instance->file_put_contents('source.txt', 'bar');
$this->instance->rename('source.txt', 'target.txt');
$this->assertEquals('bar', $this->instance->file_get_contents('target.txt'));
$this->assertFalse($this->instance->file_exists('source.txt'));
}
public function testRenameDirectory() {
$this->instance->mkdir('source');
$this->instance->file_put_contents('source/test1.txt', 'foo');
$this->instance->file_put_contents('source/test2.txt', 'qwerty');
$this->instance->mkdir('source/subfolder');
$this->instance->file_put_contents('source/subfolder/test.txt', 'bar');
$this->instance->rename('source', 'target');
$this->assertFalse($this->instance->file_exists('source'));
$this->assertFalse($this->instance->file_exists('source/test1.txt'));
$this->assertFalse($this->instance->file_exists('source/test2.txt'));
$this->assertFalse($this->instance->file_exists('source/subfolder'));
$this->assertFalse($this->instance->file_exists('source/subfolder/test.txt'));
$this->assertTrue($this->instance->file_exists('target'));
$this->assertTrue($this->instance->file_exists('target/test1.txt'));
$this->assertTrue($this->instance->file_exists('target/test2.txt'));
$this->assertTrue($this->instance->file_exists('target/subfolder'));
$this->assertTrue($this->instance->file_exists('target/subfolder/test.txt'));
$this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'));
$this->assertEquals('qwerty', $this->instance->file_get_contents('target/test2.txt'));
$this->assertEquals('bar', $this->instance->file_get_contents('target/subfolder/test.txt'));
}
public function testRenameOverWriteDirectory() {
$this->instance->mkdir('source');
$this->instance->file_put_contents('source/test1.txt', 'foo');
$this->instance->mkdir('target');
$this->instance->file_put_contents('target/test1.txt', 'bar');
$this->instance->file_put_contents('target/test2.txt', 'bar');
$this->assertTrue($this->instance->rename('source', 'target'), 'rename must return true on success');
$this->assertFalse($this->instance->file_exists('source'), 'source has not been removed');
$this->assertFalse($this->instance->file_exists('source/test1.txt'), 'source/test1.txt has not been removed');
$this->assertFalse($this->instance->file_exists('target/test2.txt'), 'target/test2.txt has not been removed');
$this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'), 'target/test1.txt has not been overwritten');
}
public function testRenameOverWriteDirectoryOverFile() {
$this->instance->mkdir('source');
$this->instance->file_put_contents('source/test1.txt', 'foo');
$this->instance->file_put_contents('target', 'bar');
$this->assertTrue($this->instance->rename('source', 'target'), 'rename must return true on success');
$this->assertFalse($this->instance->file_exists('source'));
$this->assertFalse($this->instance->file_exists('source/test1.txt'));
$this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'));
}
public function testCopyDirectory() {
$this->instance->mkdir('source');
$this->instance->file_put_contents('source/test1.txt', 'foo');
$this->instance->file_put_contents('source/test2.txt', 'qwerty');
$this->instance->mkdir('source/subfolder');
$this->instance->file_put_contents('source/subfolder/test.txt', 'bar');
$this->instance->copy('source', 'target');
$this->assertTrue($this->instance->file_exists('source'));
$this->assertTrue($this->instance->file_exists('source/test1.txt'));
$this->assertTrue($this->instance->file_exists('source/test2.txt'));
$this->assertTrue($this->instance->file_exists('source/subfolder'));
$this->assertTrue($this->instance->file_exists('source/subfolder/test.txt'));
$this->assertTrue($this->instance->file_exists('target'));
$this->assertTrue($this->instance->file_exists('target/test1.txt'));
$this->assertTrue($this->instance->file_exists('target/test2.txt'));
$this->assertTrue($this->instance->file_exists('target/subfolder'));
$this->assertTrue($this->instance->file_exists('target/subfolder/test.txt'));
$this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'));
$this->assertEquals('qwerty', $this->instance->file_get_contents('target/test2.txt'));
$this->assertEquals('bar', $this->instance->file_get_contents('target/subfolder/test.txt'));
}
public function testCopyOverWriteDirectory() {
$this->instance->mkdir('source');
$this->instance->file_put_contents('source/test1.txt', 'foo');
$this->instance->mkdir('target');
$this->instance->file_put_contents('target/test1.txt', 'bar');
$this->instance->file_put_contents('target/test2.txt', 'bar');
$this->instance->copy('source', 'target');
$this->assertFalse($this->instance->file_exists('target/test2.txt'));
$this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'));
}
public function testCopyOverWriteDirectoryOverFile() {
$this->instance->mkdir('source');
$this->instance->file_put_contents('source/test1.txt', 'foo');
$this->instance->file_put_contents('target', 'bar');
$this->instance->copy('source', 'target');
$this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'));
}
public function testInstanceOfStorage() {
$this->assertTrue($this->instance->instanceOfStorage('\OCP\Files\Storage'));
$this->assertTrue($this->instance->instanceOfStorage(get_class($this->instance)));
$this->assertFalse($this->instance->instanceOfStorage('\OC'));
}
/**
* @dataProvider copyAndMoveProvider
*/
public function testCopyFromSameStorage($source, $target) {
$this->initSourceAndTarget($source);
$this->instance->copyFromStorage($this->instance, $source, $target);
$this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
$this->assertSameAsLorem($target);
$this->assertTrue($this->instance->file_exists($source), $source . ' was deleted');
}
2015-09-23 15:26:55 +03:00
public function testIsCreatable() {
$this->instance->mkdir('source');
$this->assertTrue($this->instance->isCreatable('source'));
}
public function testIsReadable() {
$this->instance->mkdir('source');
$this->assertTrue($this->instance->isReadable('source'));
}
public function testIsUpdatable() {
$this->instance->mkdir('source');
$this->assertTrue($this->instance->isUpdatable('source'));
}
public function testIsDeletable() {
$this->instance->mkdir('source');
$this->assertTrue($this->instance->isDeletable('source'));
}
public function testIsShareable() {
$this->instance->mkdir('source');
$this->assertTrue($this->instance->isSharable('source'));
}
2015-12-15 15:48:17 +03:00
public function testStatAfterWrite() {
$this->instance->file_put_contents('foo.txt', 'bar');
$stat = $this->instance->stat('foo.txt');
$this->assertEquals(3, $stat['size']);
$fh = $this->instance->fopen('foo.txt', 'w');
fwrite($fh, 'qwerty');
fclose($fh);
$stat = $this->instance->stat('foo.txt');
$this->assertEquals(6, $stat['size']);
}
public function testPartFile() {
$this->instance->file_put_contents('bar.txt.part', 'bar');
$this->instance->rename('bar.txt.part', 'bar.txt');
$this->assertEquals('bar', $this->instance->file_get_contents('bar.txt'));
}
public function testWriteStream() {
$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
if (!$this->instance->instanceOfStorage(IWriteStreamStorage::class)) {
$this->markTestSkipped('Not a WriteSteamStorage');
}
/** @var IWriteStreamStorage $storage */
$storage = $this->instance;
$source = fopen($textFile, 'r');
$storage->writeStream('test.txt', $source);
$this->assertTrue($storage->file_exists('test.txt'));
$this->assertEquals(file_get_contents($textFile), $storage->file_get_contents('test.txt'));
}
}