Skip to:
Content

BuddyPress.org

Ticket #4482: 4482.patch

File 4482.patch, 26.0 KB (added by boonebgorges, 7 years ago)
  • bp-core/bp-core-classes.php

    diff --git bp-core/bp-core-classes.php bp-core/bp-core-classes.php
    index 5e4afe7..a0096d1 100644
    class BP_User_Query { 
    4848        /** Variables *************************************************************/
    4949
    5050        /**
     51         * Unaltered params as passed to the constructor
     52         *
     53         * @since BuddyPress (1.8)
     54         * @var array
     55         */
     56        public $query_vars_raw = array();
     57
     58        /**
    5159         * Array of variables to query with
    5260         *
    5361         * @since BuddyPress (1.7)
    class BP_User_Query { 
    119127         * @param string|array $query The query variables
    120128         */
    121129        public function __construct( $query = null ) {
    122                 if ( ! empty( $query ) ) {
    123                         $this->query_vars = wp_parse_args( $query, array(
     130                // Store the raw query vars for later access
     131                $this->query_vars_raw = $query;
     132
     133                // Allow extending classes to register action/filter hooks
     134                $this->setup_hooks();
     135
     136                if ( ! empty( $this->query_vars_raw ) ) {
     137                        $this->query_vars = wp_parse_args( $this->query_vars_raw, array(
    124138                                'type'            => 'newest',
    125139                                'per_page'        => 0,
    126140                                'page'            => 1,
    class BP_User_Query { 
    162176        }
    163177
    164178        /**
     179         * Allow extending classes to set up action/filter hooks
     180         *
     181         * When extending BP_User_Query, you may need to use some of its
     182         * internal hooks to modify the output. It's not convenient to call
     183         * add_action() or add_filter() in your class constructor, because
     184         * BP_User_Query::__construct() contains a fair amount of logic that
     185         * you may not want to override in your class. Define this method in
     186         * your own class if you need a place where your extending class can
     187         * add its hooks early in the query-building process. See
     188         * BP_Group_Member_Query::setup_hooks() for an example.
     189         *
     190         * @since BuddyPress (1.8)
     191         */
     192        public function setup_hooks() {}
     193
     194        /**
    165195         * Prepare the query for user_ids
    166196         *
    167197         * @since BuddyPress (1.7)
    class BP_User_Query { 
    282312                /** WHERE *************************************************************/
    283313
    284314                // 'include' - User ids to include in the results
    285                 if ( false !== $include ) {
    286                         $include        = wp_parse_id_list( $include );
    287                         $include_ids    = $wpdb->escape( implode( ',', (array) $include ) );
     315                $include = ! empty( $include ) ? wp_parse_id_list( $include ) : array();
     316                $include_ids = $this->get_include_ids( $include );
     317                if ( ! empty( $include_ids ) ) {
     318                        $include_ids    = implode( ',', wp_parse_id_list( $include_ids ) );
    288319                        $sql['where'][] = "u.{$this->uid_name} IN ({$include_ids})";
    289320                }
    290321
    class BP_User_Query { 
    428459        }
    429460
    430461        /**
     462         * Fetches the ids of users to put in the IN clause of the main query
     463         *
     464         * By default, returns the value passed to it
     465         * ($this->query_vars['include']). Having this abstracted into a
     466         * standalone method means that extending classes can override the
     467         * logic, parsing together their own user_id limits with the 'include'
     468         * ids passed to the class constructor. See BP_Group_Member_Query for
     469         * an example.
     470         *
     471         * @since BuddyPress (1.8)
     472         * @param array Sanitized array of user ids, as passed to the 'include'
     473         *   parameter of the class constructor
     474         * @return array The list of users to which the main query should be
     475         *   limited
     476         */
     477        public function get_include_ids( $include ) {
     478                return $include;
     479        }
     480
     481        /**
    431482         * Perform a database query to populate any extra metadata we might need.
    432483         * Different components will hook into the 'bp_user_query_populate_extras'
    433484         * action to loop in the things they want.
  • bp-groups/bp-groups-classes.php

    diff --git bp-groups/bp-groups-classes.php bp-groups/bp-groups-classes.php
    index 0541788..ccd669e 100644
    class BP_Groups_Group { 
    945945        }
    946946}
    947947
     948/**
     949 * Query for the members of a group
     950 *
     951 * @since BuddyPress (1.8)
     952 */
     953class BP_Group_Member_Query extends BP_User_Query {
     954        /**
     955         * Set up action hooks
     956         *
     957         * @since BuddyPress (1.8)
     958         */
     959        public function setup_hooks() {
     960                // Take this early opportunity to set the default 'type' param
     961                // to 'last_modified', which will ensure that BP_User_Query
     962                // trusts our order and does not try to apply its own
     963                if ( empty( $this->query_vars_raw['type'] ) ) {
     964                        $this->query_vars_raw['type'] = 'last_modified';
     965                }
     966
     967                // Set up our populate_extras method
     968                add_action( 'bp_user_query_populate_extras', array( $this, 'populate_group_member_extras' ), 10, 2 );
     969        }
     970
     971        /**
     972         * Get a list of user_ids to include in the IN clause of the main query
     973         *
     974         * Overrides BP_User_Query::get_include_ids(), adding our additional
     975         * group-member logic.
     976         *
     977         * @since BuddyPress (1.8)
     978         * @param array
     979         * @return array
     980         */
     981        public function get_include_ids( $include ) {
     982                // The following args are specific to group member queries, and
     983                // are not present in the query_vars of a normal BP_User_Query.
     984                // We loop through to make sure that defaults are set (though
     985                // values passed to the constructor will, as usual, override
     986                // these defaults).
     987                $this->query_vars = wp_parse_args( $this->query_vars, array(
     988                        'group_id'       => 0,
     989                        'group_role'     => array( 'member' ),
     990                        'exclude_banned' => true,
     991                ) );
     992
     993                $group_member_ids = $this->get_group_member_ids();
     994
     995                if ( ! empty( $include ) ) {
     996                        $group_member_ids = array_intersect( $include, $group_member_ids );
     997                }
     998
     999                return $group_member_ids;
     1000        }
     1001
     1002        /**
     1003         * Get the members of the queried group
     1004         *
     1005         * @since BuddyPress (1.8)
     1006         * @return array $ids User IDs of relevant group member ids
     1007         */
     1008        protected function get_group_member_ids() {
     1009                global $wpdb, $bp;
     1010
     1011                $sql = array(
     1012                        'select'  => "SELECT user_id FROM {$bp->groups->table_name_members}",
     1013                        'where'   => array(),
     1014                        'orderby' => '',
     1015                        'order'   => '',
     1016                        'limit'   => '',
     1017                );
     1018
     1019                /** WHERE clauses ********************************************/
     1020
     1021                $sql['where'][] = $wpdb->prepare( "group_id = %d", $this->query_vars['group_id'] );
     1022
     1023                // Role information is stored as follows: admins have
     1024                // is_admin = 1, mods have is_mod = 1, and members have both
     1025                // set to 0.
     1026                $roles = $this->query_vars['group_role'];
     1027                if ( ! is_array( $roles ) ) {
     1028                        $roles = explode( ',', $roles );
     1029                }
     1030
     1031                // Sanitize: Only 'admin', 'mod', and 'member' are valid
     1032                foreach ( $roles as $role_key => $role_value ) {
     1033                        if ( ! in_array( $role_value, array( 'admin', 'mod', 'member' ) ) ) {
     1034                                unset( $roles[ $role_key ] );
     1035                        }
     1036                }
     1037
     1038                // Remove dupes to make the count accurate, and flip for faster
     1039                // isset() lookups
     1040                $roles = array_flip( array_unique( $roles ) );
     1041
     1042                switch ( count( $roles ) ) {
     1043                        case 3 :
     1044                        default :
     1045                                // All three roles means we don't limit results
     1046                                $roles_sql = '';
     1047                                break;
     1048
     1049                        case 2 :
     1050                                if ( isset( $roles['member'] ) ) {
     1051                                        // member + mod = no admins
     1052                                        // member + admin = no mods
     1053                                        $roles_sql = isset( $roles['admin'] ) ? "is_mod = 0" : "is_admin = 0";
     1054
     1055                                } else {
     1056                                        // Two non-member roles must be 'admin'
     1057                                        // and 'mod'
     1058                                        $roles_sql = "(is_admin = 1 OR is_mod = 1)";
     1059                                }
     1060                                break;
     1061
     1062                        case 1 :
     1063                                if ( isset( $roles['member'] ) ) {
     1064                                        // member only means no admins or mods
     1065                                        $roles_sql = "is_admin = 0 AND is_mod = 0";
     1066                                } else {
     1067                                        // Filter by that role only
     1068                                        $roles_sql = isset( $roles['admin'] ) ? "is_admin = 1" : "is_mod = 1";
     1069                                }
     1070                                break;
     1071
     1072                        case 0 :
     1073                                // No roles means no users should be returned
     1074                                $roles_sql = $this->no_results['where'];
     1075                                break;
     1076                }
     1077
     1078                if ( ! empty( $roles_sql ) ) {
     1079                        $sql['where'][] = $roles_sql;
     1080                }
     1081
     1082                if ( ! empty( $this->query_vars['exclude_banned'] ) ) {
     1083                        $sql['where'][] = "is_banned = 0";
     1084                }
     1085
     1086                $sql['where'] = ! empty( $sql['where'] ) ? 'WHERE ' . implode( ' AND ', $sql['where'] ) : '';
     1087
     1088                /** ORDER BY clause *******************************************/
     1089
     1090                // @todo For now, mimicking legacy behavior of
     1091                // bp_group_has_members(), which has us order by date_modified
     1092                // only. Should abstract it in the future
     1093                $sql['orderby'] = "ORDER BY date_modified";
     1094                $sql['order']   = "DESC";
     1095
     1096                /** LIMIT clause *********************************************/
     1097
     1098                // Technically, this is also handled by BP_User_Query, but
     1099                // repeating the limit here helps to make the query more
     1100                // efficient, by not fetching every single matching user
     1101                if ( ! empty( $this->query_vars['per_page'] ) && ! empty( $this->query_vars['page'] ) ) {
     1102                        $sql['limit'] = $wpdb->prepare( "LIMIT %d, %d", intval( ( $this->query_vars['page'] - 1 ) * $this->query_vars['per_page'] ), intval( $this->query_vars['per_page'] ) );
     1103                }
     1104
     1105                $ids = $wpdb->get_col( "{$sql['select']} {$sql['where']} {$sql['orderby']} {$sql['order']} {$sql['limit']}" );
     1106
     1107                return $ids;
     1108        }
     1109
     1110        /**
     1111         * Fetch additional data required in bp_group_has_members() loops
     1112         *
     1113         * @since BuddyPress (1.8)
     1114         * @param object $query BP_User_Query object. Because we're filtering
     1115         *   the current object, we use $this inside of the method instead
     1116         * @param string $user_ids_sql Sanitized, comma-separated string of
     1117         *   the user ids returned by the main query
     1118         */
     1119        public function populate_group_member_extras( $query, $user_ids_sql ) {
     1120                global $bp, $wpdb;
     1121
     1122                $extras = $wpdb->get_results( $wpdb->prepare( "SELECT user_id, date_modified, is_banned FROM {$bp->groups->table_name_members} WHERE user_id IN ({$user_ids_sql}) AND group_id = %d", $this->query_vars['group_id'] ) );
     1123
     1124                foreach ( (array) $extras as $extra ) {
     1125                        if ( isset( $this->results[ $extra->user_id ] ) ) {
     1126                                // user_id is provided for backward compatibility
     1127                                $this->results[ $extra->user_id ]->user_id = (int) $extra->user_id;
     1128                                $this->results[ $extra->user_id ]->date_modified = $extra->date_modified;
     1129                                $this->results[ $extra->user_id ]->is_banned = (int) $extra->is_banned;
     1130                        }
     1131                }
     1132
     1133                // Don't filter other BP_User_Query objects on the same page
     1134                remove_action( 'bp_user_query_populate_extras', array( $this, 'populate_group_member_extras' ), 10, 2 );
     1135        }
     1136}
     1137
    9481138class BP_Groups_Member {
    9491139        var $id;
    9501140        var $group_id;
    class BP_Groups_Member { 
    13971587        function get_all_for_group( $group_id, $limit = false, $page = false, $exclude_admins_mods = true, $exclude_banned = true, $exclude = false ) {
    13981588                global $bp, $wpdb;
    13991589
     1590                _deprecated_function( __METHOD__, '1.8', 'BP_Group_Member_Query' );
     1591
    14001592                $pag_sql = '';
    14011593                if ( !empty( $limit ) && !empty( $page ) )
    14021594                        $pag_sql = $wpdb->prepare( "LIMIT %d, %d", intval( ( $page - 1 ) * $limit), intval( $limit ) );
  • bp-groups/bp-groups-functions.php

    diff --git bp-groups/bp-groups-functions.php bp-groups/bp-groups-functions.php
    index 42659e5..b1be906 100644
    function groups_get_group_mods( $group_id ) { 
    382382/**
    383383 * Fetch the members of a group
    384384 *
    385  * Procedural wrapper for BP_Groups_Member::get_all_for_group().
     385 * Since BuddyPress 1.8, a procedural wrapper for BP_Group_Member_Query.
     386 * Previously called BP_Groups_Member::get_all_for_group().
     387 *
     388 * To use the legacy query, filter 'bp_use_legacy_group_member_query',
     389 * returning true.
    386390 *
    387391 * @param int $group_id
    388392 * @param int $limit Maximum members to return
    function groups_get_group_mods( $group_id ) { 
    392396 * @param array|string $exclude Array or comma-sep list of users to exclude
    393397 * @return array Multi-d array of 'members' list and 'count'
    394398 */
    395 function groups_get_group_members( $group_id, $limit = false, $page = false, $exclude_admins_mods = true, $exclude_banned = true, $exclude = false ) {
    396         return BP_Groups_Member::get_all_for_group( $group_id, $limit, $page, $exclude_admins_mods, $exclude_banned, $exclude );
     399function groups_get_group_members( $group_id, $limit = false, $page = false, $exclude_admins_mods = true, $exclude_banned = true, $exclude = false, $group_role = false ) {
     400
     401        // For legacy users. Use of BP_Groups_Member::get_all_for_group()
     402        // is deprecated.
     403        if ( apply_filters( 'bp_use_legacy_group_member_query', false, __FUNCTION__, func_get_args() ) ) {
     404                $retval = BP_Groups_Member::get_all_for_group( $group_id, $limit, $page, $exclude_admins_mods, $exclude_banned, $exclude );
     405        } else {
     406                // exclude_admins_mods is a legacy argument. Convert to
     407                // group_role
     408                if ( empty( $group_role ) ) {
     409                        $group_role = $exclude_admins_mods ? array( 'member' ) : array( 'member', 'mod', 'admin' );
     410                }
     411
     412                $params = array(
     413                        'group_id'       => $group_id,
     414                        'per_page'       => $limit,
     415                        'page'           => $page,
     416                        'group_role'     => $group_role,
     417                        'exclude_banned' => $exclude_banned,
     418                        'exclude'        => $exclude,
     419                        'type'           => 'last_modified',
     420                );
     421                $members = new BP_Group_Member_Query( $params );
     422
     423                // Structure the return value as expected by the template
     424                // functions
     425                $retval = array(
     426                        'members' => array_values( $members->results ),
     427                        'count'   => $members->total_users
     428                );
     429        }
     430
     431        return $retval;
    397432}
    398433
    399434function groups_get_total_member_count( $group_id ) {
  • bp-groups/bp-groups-template.php

    diff --git bp-groups/bp-groups-template.php bp-groups/bp-groups-template.php
    index ee73b19..fc9d941 100644
    class BP_Groups_Group_Members_Template { 
    18971897        var $pag_links;
    18981898        var $total_group_count;
    18991899
    1900         function __construct( $group_id, $per_page, $max, $exclude_admins_mods, $exclude_banned, $exclude ) {
     1900        function __construct( $group_id, $per_page, $max, $exclude_admins_mods, $exclude_banned, $exclude, $group_role = false ) {
    19011901
    19021902                $this->pag_page = isset( $_REQUEST['mlpage'] ) ? intval( $_REQUEST['mlpage'] ) : 1;
    19031903                $this->pag_num  = isset( $_REQUEST['num'] ) ? intval( $_REQUEST['num'] ) : $per_page;
    1904                 $this->members  = BP_Groups_Member::get_all_for_group( $group_id, $this->pag_num, $this->pag_page, $exclude_admins_mods, $exclude_banned, $exclude );
     1904                $this->members  = groups_get_group_members( $group_id, $this->pag_num, $this->pag_page, $exclude_admins_mods, $exclude_banned, $exclude, $group_role );
    19051905
    19061906                if ( !$max || $max >= (int) $this->members['count'] )
    19071907                        $this->total_member_count = (int) $this->members['count'];
    function bp_group_has_members( $args = '' ) { 
    19831983                'max' => false,
    19841984                'exclude' => false,
    19851985                'exclude_admins_mods' => 1,
    1986                 'exclude_banned' => 1
     1986                'exclude_banned' => 1,
     1987                'group_role' => false,
    19871988        ) );
    19881989
    1989         $members_template = new BP_Groups_Group_Members_Template( $r['group_id'], $r['per_page'], $r['max'], (int) $r['exclude_admins_mods'], (int) $r['exclude_banned'], $r['exclude'] );
     1990        $members_template = new BP_Groups_Group_Members_Template( $r['group_id'], $r['per_page'], $r['max'], (int) $r['exclude_admins_mods'], (int) $r['exclude_banned'], $r['exclude'], $r['group_role'] );
    19901991        return apply_filters( 'bp_group_has_members', $members_template->has_members(), $members_template );
    19911992}
    19921993
  • tests/includes/testcase.php

    diff --git tests/includes/testcase.php tests/includes/testcase.php
    index 3f6b470..53ae4cc 100644
    class BP_UnitTestCase extends WP_UnitTestCase { 
    223223                return $user_id;
    224224        }
    225225
    226         public static function add_user_to_group( $user_id, $group_id ) {
     226        public static function add_user_to_group( $user_id, $group_id, $args = array() ) {
     227                $r = wp_parse_args( $args, array(
     228                        'date_modified' => bp_core_current_time(),
     229                ) );
     230
    227231                $new_member                = new BP_Groups_Member;
    228232                $new_member->group_id      = $group_id;
    229233                $new_member->user_id       = $user_id;
    230234                $new_member->inviter_id    = 0;
    231235                $new_member->is_admin      = 0;
    232236                $new_member->user_title    = '';
    233                 $new_member->date_modified = bp_core_current_time();
     237                $new_member->date_modified = $r['date_modified'];
    234238                $new_member->is_confirmed  = 1;
    235239
    236240                $new_member->save();
  • new file tests/testcases/groups/class-bp-group-member-query.php

    diff --git tests/testcases/groups/class-bp-group-member-query.php tests/testcases/groups/class-bp-group-member-query.php
    new file mode 100644
    index 0000000..b46ad5c
    - +  
     1<?php
     2/**
     3 * @group groups
     4 * @group BP_Group_Member_Query
     5 */
     6class BP_Tests_BP_Group_Member_Query_TestCases extends BP_UnitTestCase {
     7        /**
     8         * Make sure that a manual 'include' param is parsed correctly with
     9         * BP_Group_Member_Query's limiting of the query to group members
     10         */
     11        public function test_with_include() {
     12                $g = $this->factory->group->create();
     13                $u1 = $this->create_user();
     14                $u2 = $this->create_user();
     15                $u3 = $this->create_user();
     16
     17                $this->add_user_to_group( $u1, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 100 ) ) );
     18                $this->add_user_to_group( $u2, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 200 ) ) );
     19
     20                $query = new BP_Group_Member_Query( array(
     21                        'group_id' => $g,
     22                        'include' => array( $u2 ),
     23                ) );
     24
     25                $ids = wp_parse_id_list( array_keys( $query->results ) );
     26                $this->assertEquals( array( $u2, ), $ids );
     27        }
     28
     29        // Make sure we're falling back on 'member'
     30        public function test_with_group_role_null() {
     31                $g = $this->factory->group->create();
     32                $u1 = $this->create_user();
     33                $u2 = $this->create_user();
     34                $u3 = $this->create_user();
     35
     36                $this->add_user_to_group( $u1, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 100 ) ) );
     37                $this->add_user_to_group( $u2, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 200 ) ) );
     38                $this->add_user_to_group( $u3, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 300 ) ) );
     39
     40                $m1 = new BP_Groups_Member( $u1, $g );
     41                $m1->promote( 'admin' );
     42                $m2 = new BP_Groups_Member( $u2, $g );
     43                $m2->promote( 'mod' );
     44
     45                $query = new BP_Group_Member_Query( array(
     46                        'group_id' => $g,
     47                ) );
     48
     49                $expected = new BP_Group_Member_Query( array(
     50                        'group_id' => $g,
     51                        'group_role' => array( 'member' ),
     52                ) );
     53
     54                $this->assertEquals( $expected->results, $query->results );
     55        }
     56
     57        public function test_with_group_role_member() {
     58                $g = $this->factory->group->create();
     59                $u1 = $this->create_user();
     60                $u2 = $this->create_user();
     61                $u3 = $this->create_user();
     62
     63                $this->add_user_to_group( $u1, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 100 ) ) );
     64                $this->add_user_to_group( $u2, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 200 ) ) );
     65                $this->add_user_to_group( $u3, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 300 ) ) );
     66
     67                $m1 = new BP_Groups_Member( $u1, $g );
     68                $m1->promote( 'admin' );
     69                $m2 = new BP_Groups_Member( $u2, $g );
     70                $m2->promote( 'mod' );
     71
     72                $query_members = new BP_Group_Member_Query( array(
     73                        'group_id' => $g,
     74                        'group_role' => array( 'member' ),
     75                ) );
     76
     77                $ids = wp_parse_id_list( array_keys( $query_members->results ) );
     78                $this->assertEquals( array( $u3, ), $ids );
     79        }
     80
     81        public function test_with_group_role_mod() {
     82                $g = $this->factory->group->create();
     83                $u1 = $this->create_user();
     84                $u2 = $this->create_user();
     85                $u3 = $this->create_user();
     86
     87                $this->add_user_to_group( $u1, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 100 ) ) );
     88                $this->add_user_to_group( $u2, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 200 ) ) );
     89                $this->add_user_to_group( $u3, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 300 ) ) );
     90
     91                $m1 = new BP_Groups_Member( $u1, $g );
     92                $m1->promote( 'admin' );
     93                $m2 = new BP_Groups_Member( $u2, $g );
     94                $m2->promote( 'mod' );
     95
     96                $query_members = new BP_Group_Member_Query( array(
     97                        'group_id' => $g,
     98                        'group_role' => array( 'mod' ),
     99                ) );
     100
     101                $ids = wp_parse_id_list( array_keys( $query_members->results ) );
     102                $this->assertEquals( array( $u2, ), $ids );
     103        }
     104
     105        public function test_with_group_role_admin() {
     106                $g = $this->factory->group->create();
     107                $u1 = $this->create_user();
     108                $u2 = $this->create_user();
     109                $u3 = $this->create_user();
     110
     111                $this->add_user_to_group( $u1, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 100 ) ) );
     112                $this->add_user_to_group( $u2, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 200 ) ) );
     113                $this->add_user_to_group( $u3, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 300 ) ) );
     114
     115                $m1 = new BP_Groups_Member( $u1, $g );
     116                $m1->promote( 'admin' );
     117                $m2 = new BP_Groups_Member( $u2, $g );
     118                $m2->promote( 'mod' );
     119
     120                $query_members = new BP_Group_Member_Query( array(
     121                        'group_id' => $g,
     122                        'group_role' => array( 'admin' ),
     123                ) );
     124
     125                $ids = wp_parse_id_list( array_keys( $query_members->results ) );
     126                $this->assertEquals( array( $u1, ), $ids );
     127        }
     128
     129        public function test_with_group_role_member_mod() {
     130                $g = $this->factory->group->create();
     131                $u1 = $this->create_user();
     132                $u2 = $this->create_user();
     133                $u3 = $this->create_user();
     134
     135                $this->add_user_to_group( $u1, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 100 ) ) );
     136                $this->add_user_to_group( $u2, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 200 ) ) );
     137                $this->add_user_to_group( $u3, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 300 ) ) );
     138
     139                $m1 = new BP_Groups_Member( $u1, $g );
     140                $m1->promote( 'admin' );
     141                $m2 = new BP_Groups_Member( $u2, $g );
     142                $m2->promote( 'mod' );
     143
     144                $query_members = new BP_Group_Member_Query( array(
     145                        'group_id' => $g,
     146                        'group_role' => array( 'member', 'mod' ),
     147                ) );
     148
     149                $ids = wp_parse_id_list( array_keys( $query_members->results ) );
     150                $this->assertEquals( array( $u2, $u3, ), $ids );
     151        }
     152
     153        public function test_with_group_role_member_admin() {
     154                $g = $this->factory->group->create();
     155                $u1 = $this->create_user();
     156                $u2 = $this->create_user();
     157                $u3 = $this->create_user();
     158
     159                $this->add_user_to_group( $u1, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 100 ) ) );
     160                $this->add_user_to_group( $u2, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 200 ) ) );
     161                $this->add_user_to_group( $u3, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 300 ) ) );
     162
     163                $m1 = new BP_Groups_Member( $u1, $g );
     164                $m1->promote( 'admin' );
     165                $m2 = new BP_Groups_Member( $u2, $g );
     166                $m2->promote( 'mod' );
     167
     168                $query_members = new BP_Group_Member_Query( array(
     169                        'group_id' => $g,
     170                        'group_role' => array( 'member', 'admin' ),
     171                ) );
     172
     173                $ids = wp_parse_id_list( array_keys( $query_members->results ) );
     174                $this->assertEquals( array( $u1, $u3, ), $ids );
     175        }
     176
     177        public function test_with_group_role_mod_admin() {
     178                $g = $this->factory->group->create();
     179                $u1 = $this->create_user();
     180                $u2 = $this->create_user();
     181                $u3 = $this->create_user();
     182
     183                $this->add_user_to_group( $u1, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 100 ) ) );
     184                $this->add_user_to_group( $u2, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 200 ) ) );
     185                $this->add_user_to_group( $u3, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 300 ) ) );
     186
     187                $m1 = new BP_Groups_Member( $u1, $g );
     188                $m1->promote( 'admin' );
     189                $m2 = new BP_Groups_Member( $u2, $g );
     190                $m2->promote( 'mod' );
     191
     192                $query_members = new BP_Group_Member_Query( array(
     193                        'group_id' => $g,
     194                        'group_role' => array( 'mod', 'admin' ),
     195                ) );
     196
     197                $ids = wp_parse_id_list( array_keys( $query_members->results ) );
     198                $this->assertEquals( array( $u1, $u2, ), $ids );
     199        }
     200
     201        public function test_with_group_role_member_mod_admin() {
     202                $g = $this->factory->group->create();
     203                $u1 = $this->create_user();
     204                $u2 = $this->create_user();
     205                $u3 = $this->create_user();
     206
     207                $this->add_user_to_group( $u1, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 100 ) ) );
     208                $this->add_user_to_group( $u2, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 200 ) ) );
     209                $this->add_user_to_group( $u3, $g, array( 'date_modified' => gmdate( 'Y-m-d H:i:s', $time - 300 ) ) );
     210
     211                $m1 = new BP_Groups_Member( $u1, $g );
     212                $m1->promote( 'admin' );
     213                $m2 = new BP_Groups_Member( $u2, $g );
     214                $m2->promote( 'mod' );
     215
     216                $query_members = new BP_Group_Member_Query( array(
     217                        'group_id' => $g,
     218                        'group_role' => array( 'member', 'mod', 'admin' ),
     219                ) );
     220
     221                $ids = wp_parse_id_list( array_keys( $query_members->results ) );
     222                $this->assertEquals( array( $u1, $u2, $u3, ), $ids );
     223        }
     224
     225
     226}
  • tests/testcases/groups/template.php

    diff --git tests/testcases/groups/template.php tests/testcases/groups/template.php
    index 2c9ed92..64a5b2a 100644
    class BP_Tests_Groups_Template extends BP_UnitTestCase { 
    117117        }
    118118
    119119        /**
     120         * Switching from BP_Groups_Member to BP_Group_Member_Query meant a
     121         * change in the format of the values returned from the query. For
     122         * backward compatibility, we translate some of the return values
     123         * of BP_Group_Member_Query to the older format. This test makes sure
     124         * that the translation happens properly.
     125         *
     126         * @group bp_group_has_members
     127         */
     128        public function test_bp_group_has_members_backpat_retval_format() {
     129                $g = $this->factory->group->create();
     130                $u1 = $this->create_user();
     131                $u2 = $this->create_user();
     132
     133                $date_modified = gmdate( 'Y-m-d H:i:s', time() - 100 );
     134
     135                $new_member                = new BP_Groups_Member;
     136                $new_member->group_id      = $g;
     137                $new_member->user_id       = $u1;
     138                $new_member->inviter_id    = $u2;
     139                $new_member->is_admin      = 0;
     140                $new_member->user_title    = '';
     141                $new_member->date_modified = $date_modified;
     142                $new_member->is_confirmed  = 1;
     143                $new_member->save();
     144
     145                global $members_template;
     146                bp_group_has_members( array(
     147                        'group_id' => $g,
     148                ) );
     149
     150                $u1_object = new WP_User( $u1 );
     151
     152                $expected = new stdClass;
     153                $expected->user_id = $u1;
     154                $expected->date_modified = $date_modified;
     155                $expected->is_banned = 0;
     156                $expected->user_login = $u1_object->user_login;
     157                $expected->user_nicename = $u1_object->user_nicename;
     158                $expected->user_email = $u1_object->user_email;
     159                $expected->display_name = $u1_object->display_name;
     160
     161                // In order to use assertEquals, we need to discard the
     162                // irrelevant properties of the found object. Hack alert
     163                $found = new stdClass;
     164                foreach ( array( 'user_id', 'date_modified', 'is_banned', 'user_login', 'user_nicename', 'user_email', 'display_name' ) as $key ) {
     165                        if ( isset( $members_template->members[0]->{$key} ) ) {
     166                                $found->{$key} = $members_template->members[0]->{$key};
     167                        }
     168                }
     169
     170                $this->assertEquals( $expected, $found );
     171        }
     172
     173        /**
    120174         * @group bp_group_has_members
    121175         */
    122176        public function test_bp_group_has_members_with_per_page() {