2012-02-12 21:06:32 +04:00
< ? 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 />.
*
*/
2012-02-12 21:06:32 +04:00
2012-09-22 16:51:15 +04:00
namespace Test\Files\Storage ;
2013-01-26 21:49:45 +04:00
abstract class Storage extends \PHPUnit_Framework_TestCase {
2012-02-12 21:06:32 +04:00
/**
2012-09-07 20:30:48 +04:00
* @ var \OC\Files\Storage\Storage instance
2012-02-12 21:06:32 +04:00
*/
protected $instance ;
2014-01-31 19:06:11 +04:00
protected $waitDelay = 0 ;
/**
* Sleep for the number of seconds specified in the
* $waitDelay attribute
*/
protected function wait () {
if ( $this -> waitDelay > 0 ) {
sleep ( $this -> waitDelay );
}
}
2012-02-12 21:06:32 +04:00
/**
* 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-02-12 21:06:32 +04:00
}
2012-10-11 21:30:27 +04:00
2013-12-03 17:35:53 +04:00
/**
* Check that the test () function works
*/
public function testTestFunction () {
$this -> assertTrue ( $this -> instance -> test ());
}
2013-10-31 14:55:58 +04:00
/**
* @ dataProvider directoryProvider
*/
public function testDirectories ( $directory ) {
2014-03-20 18:32:12 +04:00
$this -> assertFalse ( $this -> instance -> file_exists ( '/' . $directory ));
2012-10-11 21:30:27 +04:00
2014-03-20 18:32:12 +04:00
$this -> assertTrue ( $this -> instance -> mkdir ( '/' . $directory ));
2012-10-11 21:30:27 +04:00
2014-03-20 18:32:12 +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 ;
2012-02-13 13:25:45 +04:00
}
}
2013-10-31 14:55:58 +04:00
$this -> assertEquals ( array ( $directory ), $content );
2012-10-11 21:30:27 +04:00
2014-03-20 18:32:12 +04:00
$this -> assertFalse ( $this -> instance -> mkdir ( '/' . $directory )); //cant create existing folders
$this -> assertTrue ( $this -> instance -> rmdir ( '/' . $directory ));
2012-10-11 21:30:27 +04:00
2014-01-31 19:06:11 +04:00
$this -> wait ();
2014-03-20 18:32:12 +04:00
$this -> assertFalse ( $this -> instance -> file_exists ( '/' . $directory ));
2012-10-11 21:30:27 +04:00
2014-03-20 18:32:12 +04:00
$this -> assertFalse ( $this -> instance -> rmdir ( '/' . $directory )); //cant 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 ;
2012-04-18 22:46:00 +04:00
}
}
2013-01-24 19:47:17 +04:00
$this -> assertEquals ( array (), $content );
2012-02-13 13:25:45 +04:00
}
2012-02-12 21:06:32 +04:00
2014-03-20 18:32:12 +04:00
public function directoryProvider () {
2013-10-31 14:55:58 +04:00
return array (
array ( 'folder' ),
array ( ' folder' ),
array ( 'folder ' ),
2014-01-31 19:06:11 +04:00
array ( 'folder with space' ),
array ( 'spéciäl földer' ),
2013-10-31 14:55:58 +04:00
);
}
2014-03-20 18:32:12 +04:00
2014-03-31 20:36:52 +04:00
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' )
);
}
2012-02-12 21:06:32 +04:00
/**
* test the various uses of file_get_contents and file_put_contents
2014-03-31 20:36:52 +04:00
*
* @ dataProvider loremFileProvider
2012-02-12 21:06:32 +04:00
*/
2014-03-31 20:36:52 +04:00
public function testGetPutContents ( $sourceFile ) {
2012-10-11 21:30:27 +04:00
$sourceText = file_get_contents ( $sourceFile );
2012-02-12 21:06:32 +04:00
//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' );
2012-02-12 21:06:32 +04:00
//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-02-12 21:06:32 +04:00
}
2012-10-11 21:30:27 +04:00
2012-02-13 13:25:45 +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
2012-10-12 00:54:39 +04:00
$pngFile = \OC :: $SERVERROOT . '/tests/data/logo-wide.png' ;
2012-10-11 21:30:27 +04:00
$this -> instance -> file_put_contents ( '/logo-wide.png' , file_get_contents ( $pngFile , 'r' ));
2013-01-24 19:47:17 +04:00
$this -> assertEquals ( 'image/png' , $this -> instance -> getMimeType ( '/logo-wide.png' ));
2012-10-11 21:30:27 +04:00
2012-10-12 00:54:39 +04:00
$svgFile = \OC :: $SERVERROOT . '/tests/data/logo-wide.svg' ;
2012-10-11 21:30:27 +04:00
$this -> instance -> file_put_contents ( '/logo-wide.svg' , file_get_contents ( $svgFile , 'r' ));
2013-01-24 19:47:17 +04:00
$this -> assertEquals ( 'image/svg+xml' , $this -> instance -> getMimeType ( '/logo-wide.svg' ));
2012-02-13 13:25:45 +04:00
}
2012-10-11 21:30:27 +04:00
2012-09-07 17:22:01 +04:00
public function testCopyAndMove () {
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 ( '/source.txt' , file_get_contents ( $textFile ));
$this -> instance -> copy ( '/source.txt' , '/target.txt' );
2012-02-27 15:20:47 +04:00
$this -> assertTrue ( $this -> instance -> file_exists ( '/target.txt' ));
2013-01-24 19:47:17 +04:00
$this -> assertEquals ( $this -> instance -> file_get_contents ( '/source.txt' ), $this -> instance -> file_get_contents ( '/target.txt' ));
2012-10-11 21:30:27 +04:00
$this -> instance -> rename ( '/source.txt' , '/target2.txt' );
2014-01-31 19:06:11 +04:00
$this -> wait ();
2012-02-27 15:20:47 +04:00
$this -> assertTrue ( $this -> instance -> file_exists ( '/target2.txt' ));
$this -> assertFalse ( $this -> instance -> file_exists ( '/source.txt' ));
2013-11-25 21:52:14 +04:00
$this -> assertEquals ( file_get_contents ( $textFile ), $this -> instance -> file_get_contents ( '/target2.txt' ));
// move to overwrite
2013-11-25 21:54:58 +04:00
$testContents = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' ;
$this -> instance -> file_put_contents ( '/target3.txt' , $testContents );
$this -> instance -> rename ( '/target2.txt' , '/target3.txt' );
$this -> assertTrue ( $this -> instance -> file_exists ( '/target3.txt' ));
2013-11-25 21:52:14 +04:00
$this -> assertFalse ( $this -> instance -> file_exists ( '/target2.txt' ));
2013-11-25 21:54:58 +04:00
$this -> assertEquals ( file_get_contents ( $textFile ), $this -> instance -> file_get_contents ( '/target3.txt' ));
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 ));
2013-01-24 19:47:17 +04:00
$this -> assertEquals ( file_get_contents ( $localFile ), file_get_contents ( $textFile ));
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' );
$localFolder = $this -> instance -> getLocalFolder ( '/folder' );
2012-08-19 04:30:33 +04:00
$this -> assertTrue ( is_dir ( $localFolder ));
2013-02-07 02:36:38 +04:00
// 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 ));
2012-08-15 19:55:54 +04:00
$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
2013-11-14 21:39:39 +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
2013-07-17 01:07:35 +04:00
if ( $this -> instance -> touch ( '/lorem.txt' , 100 ) !== false ) {
2012-10-11 21:30:27 +04:00
$mTime = $this -> instance -> filemtime ( '/lorem.txt' );
2013-07-17 01:07:35 +04:00
$this -> assertEquals ( $mTime , 100 );
2012-03-02 21:42:04 +04:00
}
2012-10-06 15:45:46 +04:00
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
}
2012-03-02 21:42:04 +04:00
2013-11-14 21:39:39 +04:00
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' ));
2014-01-31 19:06:11 +04:00
$this -> wait ();
2013-11-14 21:39:39 +04:00
$this -> assertFalse ( $this -> instance -> file_exists ( '/lorem.txt' ));
}
2012-10-11 21:38:32 +04:00
public function testFOpen () {
2012-10-12 00:54:39 +04:00
$textFile = \OC :: $SERVERROOT . '/tests/data/lorem.txt' ;
2012-10-11 21:38:32 +04:00
$fh = @ $this -> instance -> fopen ( 'foo' , 'r' );
if ( $fh ) {
fclose ( $fh );
}
$this -> assertFalse ( $fh );
$this -> assertFalse ( $this -> instance -> file_exists ( 'foo' ));
$fh = $this -> instance -> fopen ( 'foo' , 'w' );
fwrite ( $fh , file_get_contents ( $textFile ));
fclose ( $fh );
$this -> assertTrue ( $this -> instance -> file_exists ( 'foo' ));
$fh = $this -> instance -> fopen ( 'foo' , 'r' );
$content = stream_get_contents ( $fh );
2013-01-24 19:47:17 +04:00
$this -> assertEquals ( file_get_contents ( $textFile ), $content );
2012-03-02 21:42:04 +04:00
}
2013-04-10 15:45:36 +04:00
2013-06-06 22:47:20 +04:00
public function testTouchCreateFile () {
2013-04-10 15:45:36 +04:00
$this -> assertFalse ( $this -> instance -> file_exists ( 'foo' ));
2013-11-26 15:53:03 +04:00
// returns true on success
$this -> assertTrue ( $this -> instance -> touch ( 'foo' ));
2013-04-10 15:45:36 +04:00
$this -> assertTrue ( $this -> instance -> file_exists ( 'foo' ));
}
2013-06-06 22:47:20 +04:00
public function testRecursiveRmdir () {
$this -> instance -> mkdir ( 'folder' );
$this -> instance -> mkdir ( 'folder/bar' );
2014-01-31 19:06:11 +04:00
$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' );
2013-11-29 15:58:57 +04:00
$this -> assertTrue ( $this -> instance -> rmdir ( 'folder' ));
2014-01-31 19:06:11 +04:00
$this -> wait ();
2013-11-29 15:58:57 +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 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' ));
2014-01-31 19:06:11 +04:00
$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' ));
}
2014-03-20 18:32:12 +04:00
2014-03-31 19:00:32 +04:00
public function hashProvider () {
2014-03-20 18:32:12 +04:00
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 ));
}
2014-03-31 19:00:32 +04:00
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 );
}
2013-07-01 19:40:19 +04:00
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/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' ));
}
2013-07-01 19:45:01 +04:00
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 -> 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 ( 'target/test2.txt' ));
$this -> assertEquals ( 'foo' , $this -> instance -> file_get_contents ( 'target/test1.txt' ));
}
2012-02-12 21:06:32 +04:00
}