Skip to:
Content

BuddyPress.org

Ticket #6278: 6278.patch

File 6278.patch, 21.4 KB (added by imath, 5 years ago)
  • src/bp-core/bp-core-avatars.php

    diff --git src/bp-core/bp-core-avatars.php src/bp-core/bp-core-avatars.php
    index c607bb2..3e264bf 100644
    add_action( 'bp_init', 'bp_core_set_avatar_constants', 3 ); 
    5252function bp_core_set_avatar_globals() {
    5353        $bp = buddypress();
    5454
    55         $bp->avatar        = new stdClass;
    56         $bp->avatar->thumb = new stdClass;
    57         $bp->avatar->full  = new stdClass;
    58 
    59         // Dimensions
    60         $bp->avatar->thumb->width  = BP_AVATAR_THUMB_WIDTH;
    61         $bp->avatar->thumb->height = BP_AVATAR_THUMB_HEIGHT;
    62         $bp->avatar->full->width   = BP_AVATAR_FULL_WIDTH;
    63         $bp->avatar->full->height  = BP_AVATAR_FULL_HEIGHT;
    64 
    65         // Upload maximums
    66         $bp->avatar->original_max_width    = BP_AVATAR_ORIGINAL_MAX_WIDTH;
    67         $bp->avatar->original_max_filesize = BP_AVATAR_ORIGINAL_MAX_FILESIZE;
    68 
    69         // Defaults
    70         $bp->avatar->thumb->default = bp_core_avatar_default_thumb();
    71         $bp->avatar->full->default  = bp_core_avatar_default();
    72 
    73         // These have to be set on page load in order to avoid infinite filter loops at runtime
    74         $bp->avatar->upload_path = bp_core_avatar_upload_path();
    75         $bp->avatar->url = bp_core_avatar_url();
    76 
    77         // Cache the root blog's show_avatars setting, to avoid unnecessary
    78         // calls to switch_to_blog()
    79         $bp->avatar->show_avatars = (bool) BP_SHOW_AVATARS;
     55        $bp->avatar = new BP_Attachment( array(
     56                // Dimensions for thumb size
     57                'thumb' => (object) array(
     58                        'width'   => BP_AVATAR_THUMB_WIDTH,
     59                        'height'  => BP_AVATAR_THUMB_WIDTH,
     60                ),
     61                // Dimensions for full size
     62                'full' => (object) array(
     63                        'width'   => BP_AVATAR_FULL_WIDTH,
     64                        'height'  => BP_AVATAR_FULL_HEIGHT,
     65                ),
     66                // Upload maximums
     67                'original_max_width'    => BP_AVATAR_ORIGINAL_MAX_WIDTH,
     68                'original_max_filesize' => BP_AVATAR_ORIGINAL_MAX_FILESIZE,
     69                // Cache the root blog's show_avatars setting, to avoid unnecessary
     70                // calls to switch_to_blog()
     71                'show_avatars'          => (bool) BP_SHOW_AVATARS,
     72                // Specific errors for avatars
     73                'upload_error_strings'  => array(
     74                        sprintf( __( 'The file you uploaded is too big. Please upload a file under %s', 'buddypress' ), size_format( BP_AVATAR_ORIGINAL_MAX_FILESIZE ) ),
     75                        __( 'Please upload only JPG, GIF or PNG photos.', 'buddypress' ),
     76                ),
     77        ) );
    8078
    8179        // Backpat for pre-1.5
    82         if ( ! defined( 'BP_AVATAR_UPLOAD_PATH' ) )
     80        if ( ! defined( 'BP_AVATAR_UPLOAD_PATH' ) ) {
    8381                define( 'BP_AVATAR_UPLOAD_PATH', $bp->avatar->upload_path );
     82        }
    8483
    8584        // Backpat for pre-1.5
    86         if ( ! defined( 'BP_AVATAR_URL' ) )
     85        if ( ! defined( 'BP_AVATAR_URL' ) ) {
    8786                define( 'BP_AVATAR_URL', $bp->avatar->url );
     87        }
    8888
    8989        do_action( 'bp_core_set_avatar_globals' );
    9090}
    function bp_core_avatar_handle_upload( $file, $upload_dir_filter ) { 
    574574         * You may want to hook into this filter if you want to override this function.
    575575         * Make sure you return false.
    576576         */
    577         if ( !apply_filters( 'bp_core_pre_avatar_handle_upload', true, $file, $upload_dir_filter ) )
     577        if ( ! apply_filters( 'bp_core_pre_avatar_handle_upload', true, $file, $upload_dir_filter ) ) {
    578578                return true;
    579 
    580         require_once( ABSPATH . '/wp-admin/includes/file.php' );
    581 
    582         $uploadErrors = array(
    583                 0 => __( 'The image was uploaded successfully', 'buddypress' ),
    584                 1 => __( 'The image exceeds the maximum allowed file size of: ', 'buddypress' ) . size_format( bp_core_avatar_original_max_filesize() ),
    585                 2 => __( 'The image exceeds the maximum allowed file size of: ', 'buddypress' ) . size_format( bp_core_avatar_original_max_filesize() ),
    586                 3 => __( 'The uploaded file was only partially uploaded.', 'buddypress' ),
    587                 4 => __( 'The image was not uploaded.', 'buddypress' ),
    588                 6 => __( 'Missing a temporary folder.', 'buddypress' )
    589         );
    590 
    591         if ( ! bp_core_check_avatar_upload( $file ) ) {
    592                 bp_core_add_message( sprintf( __( 'Your upload failed. Please try again. Error was: %s', 'buddypress' ), $uploadErrors[$file['file']['error']] ), 'error' );
    593                 return false;
    594579        }
    595580
    596         if ( ! bp_core_check_avatar_size( $file ) ) {
    597                 bp_core_add_message( sprintf( __( 'The file you uploaded is too big. Please upload a file under %s', 'buddypress' ), size_format( bp_core_avatar_original_max_filesize() ) ), 'error' );
    598                 return false;
    599         }
    600 
    601         if ( ! bp_core_check_avatar_type( $file ) ) {
    602                 bp_core_add_message( __( 'Please upload only JPG, GIF or PNG photos.', 'buddypress' ), 'error' );
    603                 return false;
    604         }
    605 
    606         // Filter the upload location
    607         add_filter( 'upload_dir', $upload_dir_filter, 10, 0 );
    608 
    609581        $bp = buddypress();
    610582
    611         $bp->avatar_admin->original = wp_handle_upload( $file['file'], array( 'action'=> 'bp_avatar_upload' ) );
     583        // Upload the file
     584        $bp->avatar_admin->original = $bp->avatar->upload( $file, $upload_dir_filter );
    612585
    613         // Remove the upload_dir filter, so that other upload URLs on the page
    614         // don't break
    615         remove_filter( 'upload_dir', $upload_dir_filter, 10, 0 );
    616 
    617         // Move the file to the correct upload location.
    618         if ( !empty( $bp->avatar_admin->original['error'] ) ) {
     586        // In case of an error, stop the process and display a feedback to the user
     587        if ( ! empty( $bp->avatar_admin->original['error'] ) ) {
    619588                bp_core_add_message( sprintf( __( 'Upload Failed! Error was: %s', 'buddypress' ), $bp->avatar_admin->original['error'] ), 'error' );
    620589                return false;
    621590        }
    function bp_core_check_avatar_type($file) { 
    926895/**
    927896 * Fetch data from the BP root blog's upload directory.
    928897 *
    929  * Handy for multisite instances because all uploads are made on the BP root
    930  * blog and we need to query the BP root blog for the upload directory data.
    931  *
    932  * This function ensures that we only need to use {@link switch_to_blog()}
    933  * once to get what we need.
    934  *
    935898 * @since BuddyPress (1.8.0)
    936899 *
    937  * @uses wp_upload_dir()
    938  *
    939900 * @param string $type The variable we want to return from the $bp->avatars
    940901 *        object. Only 'upload_path' and 'url' are supported. Default: 'upload_path'.
    941902 * @return string The avatar upload directory path.
    function bp_core_check_avatar_type($file) { 
    943904function bp_core_get_upload_dir( $type = 'upload_path' ) {
    944905        $bp = buddypress();
    945906
    946         switch ( $type ) {
    947                 case 'upload_path' :
    948                         $constant = 'BP_AVATAR_UPLOAD_PATH';
    949                         $key      = 'basedir';
    950 
    951                         break;
    952 
    953                 case 'url' :
    954                         $constant = 'BP_AVATAR_URL';
    955                         $key      = 'baseurl';
    956 
    957                         break;
    958 
    959                 default :
    960                         return false;
    961 
    962                         break;
    963         }
    964 
    965         // See if the value has already been calculated and stashed in the $bp global
    966         if ( isset( $bp->avatar->$type ) ) {
    967                 $retval = $bp->avatar->$type;
    968         } else {
    969                 // If this value has been set in a constant, just use that
    970                 if ( defined( $constant ) ) {
    971                         $retval = constant( $constant );
    972                 } else {
    973 
    974                         // Use cached upload dir data if available
    975                         if ( ! empty( $bp->avatar->upload_dir ) ) {
    976                                 $upload_dir = $bp->avatar->upload_dir;
    977 
    978                         // No cache, so query for it
    979                         } else {
    980                                 // We need to switch to the root blog on multisite installs
    981                                 if ( is_multisite() ) {
    982                                         switch_to_blog( bp_get_root_blog_id() );
    983                                 }
    984 
    985                                 // Get upload directory information from current site
    986                                 $upload_dir = wp_upload_dir();
    987 
    988                                 // Will bail if not switched
    989                                 restore_current_blog();
    990 
    991                                 // Stash upload directory data for later use
    992                                 $bp->avatar->upload_dir = $upload_dir;
    993                         }
    994 
    995                         // Directory does not exist and cannot be created
    996                         if ( ! empty( $upload_dir['error'] ) ) {
    997                                 $retval = '';
    998 
    999                         } else {
    1000                                 $retval = $upload_dir[$key];
    1001 
    1002                                 // If $key is 'baseurl', check to see if we're on SSL
    1003                                 // Workaround for WP13941, WP15928, WP19037.
    1004                                 if ( $key == 'baseurl' && is_ssl() ) {
    1005                                         $retval = str_replace( 'http://', 'https://', $retval );
    1006                                 }
    1007                         }
    1008 
    1009                 }
    1010 
    1011                 // Stash in $bp for later use
    1012                 $bp->avatar->$type = $retval;
     907        if ( ! isset( $bp->avatar->{$type} ) ) {
     908                return false;
    1013909        }
    1014910
    1015         return $retval;
     911        return $bp->avatar->{$type};
    1016912}
    1017913
    1018914/**
  • src/bp-core/bp-core-classes.php

    diff --git src/bp-core/bp-core-classes.php src/bp-core/bp-core-classes.php
    index b50325d..58187c0 100644
    require dirname( __FILE__ ) . '/classes/class-bp-walker-nav-menu-checklist.php'; 
    2020require dirname( __FILE__ ) . '/classes/class-bp-suggestions.php';
    2121require dirname( __FILE__ ) . '/classes/class-bp-members-suggestions.php';
    2222require dirname( __FILE__ ) . '/classes/class-bp-recursive-query.php';
     23require dirname( __FILE__ ) . '/classes/class-bp-attachment.php';
  • src/bp-core/classes/class-bp-attachment.php

    diff --git src/bp-core/classes/class-bp-attachment.php src/bp-core/classes/class-bp-attachment.php
    index e69de29..3a6a0b7 100644
     
     1<?php
     2/**
     3 * Core component classes.
     4 *
     5 * @package BuddyPress
     6 * @subpackage Core
     7 */
     8
     9// Exit if accessed directly
     10defined( 'ABSPATH' ) || exit;
     11
     12/**
     13 * BP Attachment class to manage your component's uploads
     14 *
     15 * @since BuddyPress (2.3.0)
     16 */
     17class BP_Attachment {
     18
     19        /** Upload properties *****************************************************/
     20
     21        /**
     22         * The id of the component the upload belongs to.
     23         *
     24         * @var string
     25         */
     26        public $component = 'avatar';
     27
     28        /**
     29         * Maximum file size in kilobytes
     30         *
     31         * @var int
     32         */
     33        public $original_max_filesize = 5120000;
     34
     35        /**
     36         * component's upload base directory.
     37         *
     38         * @var string
     39         */
     40        public $base_dir = '';
     41
     42        /**
     43         * The upload action.
     44         * Defaults to the avatar upload action
     45         *
     46         * @var string
     47         */
     48        public $action = 'bp_avatar_upload';
     49
     50        /**
     51         * The file input name attribute
     52         *
     53         * @var string
     54         */
     55        public $file_input = 'file';
     56
     57        /**
     58         * List of upload errors.
     59         *
     60         * @var array
     61         */
     62        public $upload_error_strings = array();
     63
     64        /**
     65         * Name of the function that will handle errors.
     66         * Defaults to the WordPress built-in handler
     67         *
     68         * @var string
     69         */
     70        public $upload_error_handler = 'wp_handle_upload_error';
     71
     72        /**
     73         * Name of the function that will contain the specific rules.
     74         *
     75         * @var string
     76         */
     77        public $upload_rules_handler = '';
     78
     79        /**
     80         * List of required core files
     81         *
     82         * @var array
     83         */
     84        public $required_wp_files = array( 'file' );
     85
     86        /**
     87         * Construct Upload parameters
     88         *
     89         * @since BuddyPress (2.3.0)
     90         *
     91         * @param array $args {
     92         *     @type string $component The id of the component the upload belongs to. Default: avatar.
     93         *     @type int    $original_max_filesize Maximum file size in kilobytes. Default: 5120000.
     94         *     @type string $base_dir component's upload base directory. Defaults to WordPress 'uploads'
     95         *     @type string $action the upload action used when uploading a file, $_POST['action'] must be set
     96         *                  and its value must equal $action {@link wp_handle_upload()}
     97         *     @type string $file_input the name attribute used in the file input. Default: file
     98         *     @type array  $upload_error_strings a list of specific error messages (optional). If set, make sure
     99         *                  to set $upload_rules_handler
     100         *     @type string $upload_error_handler the function that will handle errors. Default: avatar wp_handle_upload_error
     101         *     @type string $upload_rules_handler the function that will check upon component's specific rules. (optional)
     102         *     @type array  $required_wp_files the list of required WordPress core files. Default: array( 'file' );
     103         * }
     104         * @uses  sanitize_key()
     105         * @uses  bp_parse_args()
     106         * @uses  BP_Attachment->set_upload_error_strings()
     107         * @uses  BP_Attachment->set_upload_dir()
     108         */
     109        public function __construct( $args = '' ) {
     110                /**
     111                 * Sanitize the component id
     112                 */
     113                if ( ! empty( $args['component'] ) ) {
     114                        $this->component = sanitize_key( $args['component'] );
     115                }
     116
     117                $params = bp_parse_args( $args, get_class_vars( __CLASS__ ), $this->component . '_upload_params' );
     118
     119                foreach ( $params as $key => $param ) {
     120                        if ( 'upload_error_strings' == $key ) {
     121                                $this->{$key} = $this->set_upload_error_strings( $param );
     122                        } else {
     123                                $this->{$key} = $param;
     124                        }
     125                }
     126
     127                // Set the path/url and base dir for uploads
     128                $this->set_upload_dir();
     129
     130                // Finally set some specific for avatar
     131                if ( 'avatar' == $this->component ) {
     132                        // Set the specific rules handler
     133                        $this->upload_rules_handler = array( $this, 'validate' );
     134
     135                        //set default thumb & full values
     136                        if ( isset( $this->thumb, $this->full ) ) {
     137                                $this->thumb->default = bp_core_avatar_default_thumb() . $this->thumb->width;
     138                                $this->full->default  = bp_core_avatar_default() . $this->full->width;
     139                        }
     140                }
     141        }
     142
     143        /**
     144         * Set data from the BP root blog's upload directory.
     145         *
     146         * Handy for multisite instances because all uploads are made on the BP root
     147         * blog and we need to query the BP root blog for the upload directory data.
     148         *
     149         * This function ensures that we only need to use {@link switch_to_blog()}
     150         * once to get what we need.
     151         *
     152         * @since BuddyPress (2.3.0)
     153         *
     154         * @uses  is_multisite()
     155         * @uses  bp_is_root_blog()
     156         * @uses  switch_to_blog()
     157         * @uses  wp_upload_dir()
     158         * @uses  restore_current_blog()
     159         */
     160        public function set_upload_dir() {
     161                if ( 'avatar' == $this->component && defined( 'BP_AVATAR_UPLOAD_PATH' ) && defined( 'BP_AVATAR_URL' ) ) {
     162                        $this->upload_path = BP_AVATAR_UPLOAD_PATH;
     163                        $this->url         = BP_AVATAR_URL;
     164                        return;
     165                }
     166
     167                $need_switch = is_multisite() && ! bp_is_root_blog();
     168
     169                // We need to switch to the root blog on multisite installs
     170                if ( $need_switch ) {
     171                        switch_to_blog( bp_get_root_blog_id() );
     172                }
     173
     174                $wp_upload_dir = wp_upload_dir();
     175
     176                if ( $need_switch ) {
     177                        restore_current_blog();
     178                }
     179
     180                if ( ! empty( $wp_upload_dir['error'] ) ) {
     181                        return;
     182                }
     183
     184                $this->upload_dir  = $wp_upload_dir;
     185                $this->upload_path = $wp_upload_dir['basedir'];
     186                $this->url         = $wp_upload_dir['baseurl'];
     187
     188                if ( is_ssl() ) {
     189                        $this->url = str_replace( 'http://', 'https://', $this->url );
     190                }
     191
     192                // Custom base dir
     193                if ( ! empty( $this->base_dir ) ) {
     194                        $this->upload_path = trailingslashit( $this->upload_path ) . $this->base_dir;
     195                        $this->url         = trailingslashit( $this->upload_path ) . $this->base_dir;
     196                }
     197        }
     198
     199        /**
     200         * Set Upload error messages
     201         *
     202         * Used into the $overrides argument of BP_Attachment->upload()
     203         *
     204         * @since BuddyPress (2.3.0)
     205         *
     206         * @param array $param a list of error messages to add to BuddyPress core ones
     207         */
     208        public function set_upload_error_strings( $param = array() ) {
     209                /**
     210                 * Index of the array is the error code
     211                 * Custom errors will start at 9 code
     212                 */
     213                return array_merge( array(
     214                        0 => __( 'The file was uploaded successfully', 'buddypress' ),
     215                        1 => __( 'The uploaded file exceeds the maximum allowed file size on this site', 'buddypress' ),
     216                        2 => sprintf( __( 'The uploaded file exceeds the maximum allowed file size of: %s', 'buddypress' ), size_format( $this->original_max_filesize ) ),
     217                        3 => __( 'The uploaded file was only partially uploaded.', 'buddypress' ),
     218                        4 => __( 'No file was uploaded.', 'buddypress' ),
     219                        5 => '',
     220                        6 => __( 'Missing a temporary folder.', 'buddypress' ),
     221                        7 => __( 'Failed to write file to disk.', 'buddypress' ),
     222                        8 => __( 'File upload stopped by extension.', 'buddypress' ),
     223                ), (array) $param );
     224        }
     225
     226        /**
     227         * Include the WordPress core needed files
     228         *
     229         * @since BuddyPress (2.3.0)
     230         */
     231        private function includes() {
     232                foreach ( $this->required_wp_files as $wp_file ) {
     233                        if ( ! file_exists( ABSPATH . "/wp-admin/includes/{$wp_file}.php" ) ) {
     234                                continue;
     235                        }
     236
     237                        require_once( ABSPATH . "/wp-admin/includes/{$wp_file}.php" );
     238                }
     239        }
     240
     241        /**
     242         * Upload the attachment
     243         *
     244         * @since BuddyPress (2.3.0)
     245         *
     246         * @param  array $file The appropriate entry the from $_FILES superglobal.
     247         * @param  string $upload_dir_filter A specific filter to be applied to 'upload_dir' (optional).
     248         * @uses   wp_handle_upload()
     249         * @uses   apply_filters() call 'bp_attachment_upload_overrides' to include specific upload overrides
     250         * @return array On success, returns an associative array of file attributes. On failure, returns
     251         *               an array containing the error message (eg: array( 'error' => $message ) )
     252         */
     253        public function upload( $file, $upload_dir_filter = '' ) {
     254                if ( ! empty( $this->upload_rules_handler ) && ! empty( $this->action ) ) {
     255                        /**
     256                         * Add custom rules before enabling the file upload
     257                         */
     258                        add_filter( "{$this->action}_prefilter", $this->upload_rules_handler, 10, 1 );
     259                }
     260
     261                /**
     262                 * If you need to add some overrides we haven't thought of
     263                 *
     264                 * @var  array $overrides the wp_handle_upload overrides
     265                 */
     266                $overrides = apply_filters( 'bp_attachment_upload_overrides', array(
     267                        'action'               => $this->action,
     268                        'upload_error_strings' => $this->upload_error_strings,
     269                ) );
     270
     271                $this->includes();
     272
     273                /**
     274                 * If the $base_dir was set when constructing the class,
     275                 * and no specific filter has been requested, use a default
     276                 * filter to create the specific $base dir
     277                 * @see  BP_Attachment->upload_dir_filter()
     278                 */
     279                if ( empty( $upload_dir_filter ) && ! empty( $this->base_dir ) ) {
     280                        $upload_dir_filter = array( $this, 'upload_dir_filter' );
     281                }
     282
     283                // Make sure the file will be uploaded in the attachment directory
     284                add_filter( 'upload_dir', $upload_dir_filter, 10, 0 );
     285
     286                // Upload the attachment
     287                $this->attachment = wp_handle_upload( $file[ $this->file_input ], $overrides );
     288
     289                // Restore WordPress Uploads data
     290                remove_filter( 'upload_dir', $upload_dir_filter, 10, 0 );
     291
     292                // Finally return the uploaded file or the error
     293                return $this->attachment;
     294        }
     295
     296        /**
     297         * Default filter to save the attachments
     298         *
     299         * @since BuddyPress (2.3.0)
     300         *
     301         * @uses   wp_mkdir_p()
     302         * @uses   do_action() call 'bp_attachment_base_upload_dir_created' to run specific action once the
     303         *                     $base_dir is created (eg: add an .htaccess file)
     304         * @uses   apply_filters() call 'bp_attachment_upload_dir' to eventually override the upload location
     305         *                         regarding to context
     306         * @return array the upload directory data
     307         */
     308        public function upload_dir_filter() {
     309                if ( ! file_exists( $this->upload_path ) ) {
     310                        @wp_mkdir_p( $this->upload_path );
     311
     312                        /**
     313                         * Use this filter if you need to run specific actions
     314                         * once the directory is created
     315                         *
     316                         * @since BuddyPress (2.3.0)
     317                         *
     318                         * @var  string $component the component id
     319                         * @var  string $base_dir the specific base dir used by the component
     320                         */
     321                        do_action( 'bp_attachment_base_upload_dir_created', $this->component, $this->base_dir );
     322                }
     323
     324                /**
     325                 * Filters the component's upload directory.
     326                 *
     327                 * @since BuddyPress (2.3.0)
     328                 *
     329                 * @param array $value Array containing the path, URL, and other helpful settings.
     330                 */
     331                return apply_filters( 'bp_attachment_upload_dir', array(
     332                        'path'    => $this->upload_path,
     333                        'url'     => $this->url,
     334                        'subdir'  => false,
     335                        'basedir' => $this->upload_path,
     336                        'baseurl' => $this->url,
     337                        'error'   => false
     338                ) );
     339        }
     340
     341        /**
     342         * Avatar specific rules
     343         *
     344         * Adds an error if the avatar size or type don't match BuddyPress needs
     345         * The error code is the index of $upload_error_strings
     346         *
     347         * @since BuddyPress (2.3.0)
     348         *
     349         * @param  array $file the temporary file attributes (before it has been moved)
     350         * @uses   bp_core_check_avatar_size()
     351         * @uses   bp_core_check_avatar_type()
     352         * @return array the file with extra errors if needed
     353         */
     354        public function validate( $file = array() ) {
     355                if ( ! empty( $file['error'] ) ) {
     356                        return $file;
     357                }
     358
     359                if ( ! bp_core_check_avatar_size( array( 'file' => $file ) ) ) {
     360                        $file['error'] = 9;
     361                } else if ( ! bp_core_check_avatar_type( array( 'file' => $file ) ) ) {
     362                        $file['error'] = 10;
     363                }
     364
     365                return $file;
     366        }
     367}
  • tests/phpunit/testcases/core/avatars.php

    diff --git tests/phpunit/testcases/core/avatars.php tests/phpunit/testcases/core/avatars.php
    index d37fe1a..d11c436 100644
    class BP_Tests_Avatars extends BP_UnitTestCase { 
    3535        }
    3636
    3737        /**
     38         * @group bp_core_set_avatar_globals
     39         */
     40        public function test_bp_core_set_avatar_globals() {
     41                $bp = buddypress();
     42
     43                $bp_avatar = $bp->avatar;
     44                $bp->avatar = new stdClass;
     45
     46                bp_core_set_avatar_globals();
     47
     48                $expected = array(
     49                        'thumb_widh'            => BP_AVATAR_THUMB_WIDTH,
     50                        'thumb_height'          => BP_AVATAR_THUMB_HEIGHT,
     51                        'full_width'            => BP_AVATAR_FULL_WIDTH,
     52                        'full_height'           => BP_AVATAR_FULL_HEIGHT,
     53                        'original_max_width'    => BP_AVATAR_ORIGINAL_MAX_WIDTH,
     54                        'original_max_filesize' => BP_AVATAR_ORIGINAL_MAX_FILESIZE,
     55                        'thumb_default'         => bp_core_avatar_default_thumb(),
     56                        'full_default'          => bp_core_avatar_default(),
     57                        'upload_path'           => bp_core_avatar_upload_path(),
     58                        'url'                   => bp_core_avatar_url(),
     59                        'show_avatars'          => (bool) BP_SHOW_AVATARS,
     60                );
     61
     62                $tested = array(
     63                        'thumb_widh'            => $bp->avatar->thumb->width,
     64                        'thumb_height'          => $bp->avatar->thumb->height,
     65                        'full_width'            => $bp->avatar->full->width,
     66                        'full_height'           => $bp->avatar->full->height,
     67                        'original_max_width'    => $bp->avatar->original_max_width,
     68                        'original_max_filesize' => $bp->avatar->original_max_filesize,
     69                        'thumb_default'         => $bp->avatar->thumb->default,
     70                        'full_default'          => $bp->avatar->full->default,
     71                        'upload_path'           => $bp->avatar->upload_path,
     72                        'url'                   => $bp->avatar->url,
     73                        'show_avatars'          => $bp->avatar->show_avatars,
     74                );
     75
     76                $this->assertSame( $expected, $tested );
     77
     78                // reset $bp->avatar
     79                $bp->avatar = $bp_avatar;
     80        }
     81
     82        /**
    3883         * @ticket BP4948
    3984         */
    4085        function test_avatars_on_non_root_blog() {