WordPress.org

Make WordPress Core

Ticket #29544: 0001-added-permissions-to-mock-filesystem-and-unit-tests-.patch

File 0001-added-permissions-to-mock-filesystem-and-unit-tests-.patch, 8.5 KB (added by mnelson4, 7 years ago)

git patch to apply to master

  • tests/phpunit/includes/mock-fs.php

    From 10154fe7ed161ca80011f143962fa1a2be9a05a6 Mon Sep 17 00:00:00 2001
    From: Michael Nelson <michael@eventespresso.com>
    Date: Fri, 5 Sep 2014 11:57:48 -0700
    Subject: [PATCH] added permissions to mock filesystem and unit tests using
     them
    
    ---
     tests/phpunit/includes/mock-fs.php             | 145 ++++++++++++++++++++++++-
     tests/phpunit/tests/filesystem/permissions.php |  58 ++++++++++
     2 files changed, 197 insertions(+), 6 deletions(-)
     create mode 100644 tests/phpunit/tests/filesystem/permissions.php
    
    diff --git a/tests/phpunit/includes/mock-fs.php b/tests/phpunit/includes/mock-fs.php
    index 8873b5c..8b6d5ff 100644
    a b  
    11<?php
     2define( 'WP_Filesystem_MockFS_default_perms' , '0777' );
     3define( 'WP_Filesystem_MockFS_default_owner' , 'wp-owner' );
     4define( 'WP_Filesystem_MockFS_default_group' , 'wp-group' );
    25class WP_Filesystem_MockFS extends WP_Filesystem_Base {
    36        private $cwd;
    47
    class WP_Filesystem_MockFS extends WP_Filesystem_Base { 
    7275
    7376        /**
    7477         * Locates a filesystem "node"
     78         * @return MockFS_Node
    7579         */
    7680        private function locate_node( $path ) {
    7781                return isset( $this->fs_map[ $path ] ) ? $this->fs_map[ $path ] : false;
    class WP_Filesystem_MockFS extends WP_Filesystem_Base { 
    99103                                return false;
    100104                }
    101105
    102                 $node = new MockFS_Directory_Node( $path );
     106                $node = new MockFS_Directory_Node( $path, $chmod, $chown, $chgrp );
    103107
    104108                $parent_node->children[ $node->name ] = $node;
    105109                $this->fs_map[ $path ] = $node;
    class WP_Filesystem_MockFS extends WP_Filesystem_Base { 
    109113
    110114        function put_contents( $path, $contents = '', $mode = null ) {
    111115                if ( ! $this->is_dir( dirname( $path ) ) )
    112                         $this->mkdir( dirname( $path ) );
     116                        $this->mkdir( dirname( $path ), $mode );
    113117
    114118                $parent = $this->locate_parent_node( $path );
    115                 $new_file = new MockFS_File_Node( $path, $contents );
     119                $new_file = new MockFS_File_Node( $path, $contents, $mode );
    116120
    117121                $parent->children[ $new_file->name ] = $new_file;
    118122                $this->fs_map[ $path ] = $new_file;
    class WP_Filesystem_MockFS extends WP_Filesystem_Base { 
    191195                return $ret;
    192196        }
    193197
     198        /**
     199         * Changes the permissions
     200         * @param string $file path to file/folder
     201         * @param string $mode
     202         * @param boolean $recursive
     203         * @return boolean success
     204         */
     205        public function chmod( $file, $mode = false, $recursive = false ) {
     206                $node = $this->locate_node( $file );
     207                if( ! $node instanceof MockFS_Node ){
     208                        return FALSE;
     209                }
     210                $node->perms = $mode;
     211                if( $node instanceof MockFS_Directory_Node && $recursive ){
     212                        foreach( $node->children as $child_node ){
     213                                $this->chmod( $child_node->path, $mode, $recursive );
     214                        }
     215                }
     216                return TRUE;
     217        }
     218        /**
     219         * CHanges the owner
     220         * @param string $file
     221         * @param string $owner name of owner
     222         * @param type $recursive
     223         */
     224        public function chown( $file, $owner, $recursive = false ) {
     225                $node = $this->locate_node( $file );
     226                if( ! $node instanceof MockFS_Node ){
     227                        return FALSE;
     228                }
     229                $node->owner = $owner;
     230                if( $node instanceof MockFS_Directory_Node && $recursive ){
     231                        foreach( $node->children as $child_node ){
     232                                $this->chown( $child_node->path, $owner, $recursive );
     233                        }
     234                }
     235                return TRUE;
     236        }
     237        /**
     238         * Sets the group name
     239         * @param string $file
     240         * @param string $group
     241         * @param boolean $recursive
     242         * @return boolean success
     243         */
     244        public function chgrp( $file, $group, $recursive = false ) {
     245                $node = $this->locate_node( $file );
     246                if( ! $node instanceof MockFS_Node ){
     247                        return FALSE;
     248                }
     249                $node->group = $group;
     250                if( $node instanceof MockFS_Directory_Node && $recursive ){
     251                        foreach( $node->children as $child_node ){
     252                                $this->chgrp( $child_node->path, $group, $recursive );
     253                        }
     254                }
     255                return TRUE;
     256        }
     257
     258        /**
     259         *
     260         * @param type $file
     261         * @return string | false on error
     262         */
     263        function owner( $file ) {
     264                $node = $this->locate_node( $file );
     265                if( ! $node instanceof MockFS_Node ){
     266                        return FALSE;
     267                }else{
     268                        return $node->owner();
     269                }
     270        }
     271
     272        /**
     273         *
     274         * @param type $file
     275         * @return string | false on error
     276         */
     277        function group( $file ) {
     278                $node = $this->locate_node( $file );
     279                if( ! $node instanceof MockFS_Node ){
     280                        return FALSE;
     281                }else{
     282                        return $node->group();
     283                }
     284        }
     285
     286        /**
     287         * Gets the permissions on the file
     288         * @return string | false on error
     289         */
     290        public function getchmod( $file ){
     291                $node = $this->locate_node( $file );
     292                if( ! $node instanceof MockFS_Node ){
     293                        return FALSE;
     294                }else{
     295                        return $node->perms();
     296                }
     297        }
     298
    194299}
    195300
    196301class MockFS_Node {
    197302        public $name; // The "name" of the entry, does not include a slash (exception, root)
    198303        public $type; // The type of the entry 'f' for file, 'd' for Directory
    199304        public $path; // The full path to the entry.
     305        public $perms; //permissions associated with this file or folder
     306        public $owner; //the owner name of the file or folder
     307        public $group; //the group of this file or folder
    200308
    201         function __construct( $path ) {
     309        function __construct( $path, $chmod = NULL, $chown = NULL, $chgrp = NULL ) {
    202310                $this->path = $path;
    203311                $this->name = basename( $path );
     312                if( ! $chmod ) {
     313                        $chmod = WP_Filesystem_MockFS_default_perms;
     314                }
     315                if( ! $chown ) {
     316                        $chown = WP_Filesystem_MockFS_default_owner;
     317                }
     318                if( ! $chgrp ) {
     319                        $chgrp = WP_Filesystem_MockFS_default_group;
     320                }
     321                $this->perms = $chmod;
     322                $this->owner = $chown;
     323                $this->group = $chgrp;
    204324        }
    205325
    206326        function is_file() {
    class MockFS_Node { 
    210330        function is_dir() {
    211331                return $this->type == 'd';
    212332        }
     333        /**
     334         *
     335         * @return string @see http://en.wikipedia.org/wiki/File_system_permissions#Numeric_notation
     336         */
     337        function perms(){
     338                return $this->perms;
     339        }
     340        function owner(){
     341                return $this->owner;
     342        }
     343        function group(){
     344                return $this->group;
     345        }
    213346}
    214347
    215348class MockFS_Directory_Node extends MockFS_Node {
    class MockFS_File_Node extends MockFS_Node { 
    221354        public $type = 'f';
    222355        public $contents = ''; // The contents of the file
    223356
    224         function __construct( $path, $contents = '' ) {
    225                 parent::__construct( $path );
     357        function __construct( $path, $contents = '', $chmod = NULL, $chown = NULL, $chgrp = NULL ) {
     358                parent::__construct( $path, $chmod, $chown, $chgrp );
    226359                $this->contents = $contents;
    227360        }
    228361}
     362 No newline at end of file
  • new file tests/phpunit/tests/filesystem/permissions.php

    diff --git a/tests/phpunit/tests/filesystem/permissions.php b/tests/phpunit/tests/filesystem/permissions.php
    new file mode 100644
    index 0000000..f072201
    - +  
     1<?php
     2/**
     3 *
     4 * permissions
     5 *
     6 * @package                     Event Espresso
     7 * @subpackage
     8 * @author                              Mike Nelson
     9 * @group filesystem
     10 */
     11class WP_Filesystem_permissions_UnitTestCases extends WP_Filesystem_UnitTestCase{
     12
     13        function test_mkdir(){
     14                global $wp_filesystem;
     15                $wp_filesystem->init('/');
     16                $folder_path = '/test/';
     17                $wp_filesystem->mkdir( $folder_path );
     18                $this->assertTrue( $wp_filesystem->exists( $folder_path ) );
     19                $this->assertEquals( WP_Filesystem_MockFS_default_perms, $wp_filesystem->getchmod( $folder_path ) );
     20                $this->assertEquals( WP_Filesystem_MockFS_default_owner, $wp_filesystem->owner( $folder_path ) );
     21                $this->assertEquals( WP_Filesystem_MockFS_default_group, $wp_filesystem->group( $folder_path ) );
     22        }
     23
     24        function test_chmod(){
     25                global $wp_filesystem;
     26                $wp_filesystem->init('/');
     27                $folder_path = '/test/';
     28                $wp_filesystem->mkdir( $folder_path );
     29                $this->assertEquals( WP_Filesystem_MockFS_default_perms, $wp_filesystem->getchmod( $folder_path ) );
     30                echo 'PERMISSIONS:' .$wp_filesystem->gethchmod( $folder_path );
     31                $wp_filesystem->chmod( $folder_path, 664 );
     32                echo 'PERMISSIONS:'.$wp_filesystem->gethchmod( $folder_path );
     33                $this->assertEquals( 664, $wp_filesystem->getchmod( $folder_path ) );
     34        }
     35
     36        function test_chown(){
     37                global $wp_filesystem;
     38                $wp_filesystem->init('/');
     39                $folder_path = '/test/';
     40                $wp_filesystem->mkdir( $folder_path );
     41                $this->assertEquals( WP_Filesystem_MockFS_default_owner, $wp_filesystem->owner( $folder_path ) );
     42                $wp_filesystem->chown( $folder_path, 'stranger');
     43                $this->assertEquals( 'stranger', $wp_filesystem->owner( $folder_path ) );
     44        }
     45
     46        function test_chgroup(){
     47                global $wp_filesystem;
     48                $wp_filesystem->init('/');
     49                $folder_path = '/test/';
     50                $wp_filesystem->mkdir( $folder_path );
     51                $this->assertEquals( WP_Filesystem_MockFS_default_group, $wp_filesystem->group( $folder_path ) );
     52                $wp_filesystem->chgrp( $folder_path, 'globe-trotters');
     53                $this->assertEquals( 'globe-trotters', $wp_filesystem->group( $folder_path ) );
     54        }
     55
     56}
     57
     58// End of file permissions.php
     59 No newline at end of file