Skip to:
Content

BuddyPress.org

Ticket #7610: 7610.01.diff

File 7610.01.diff, 23.1 KB (added by dcavins, 7 years ago)

Use bp_current_user_can() for permission checks in the groups component.

  • src/bp-forums/bp-forums-screens.php

    diff --git src/bp-forums/bp-forums-screens.php src/bp-forums/bp-forums-screens.php
    index 7b8a435..6cf4bba 100644
    function bp_forums_directory_forums_setup() { 
    4545                        $bp->groups->current_group = groups_get_group( array( 'group_id' => $_POST['topic_group_id'] ) );
    4646                        if ( !empty( $bp->groups->current_group->id ) ) {
    4747                                // Auto join this user if they are not yet a member of this group.
    48                                 if ( !bp_current_user_can( 'bp_moderate' ) && 'public' == $bp->groups->current_group->status && !groups_is_user_member( bp_loggedin_user_id(), $bp->groups->current_group->id ) )
     48                                if ( ! bp_current_user_can( 'bp_moderate' ) && bp_current_user_can( 'groups_join_group', array( 'group_id' => $bp->groups->current_group->id ) ) )
    4949                                        groups_join_group( $bp->groups->current_group->id );
    5050
    5151                                $error_message = '';
  • src/bp-groups/bp-groups-actions.php

    diff --git src/bp-groups/bp-groups-actions.php src/bp-groups/bp-groups-actions.php
    index 4f80495..e1ff5a2 100644
    function groups_action_join_group() { 
    423423        if ( !groups_is_user_member( bp_loggedin_user_id(), $bp->groups->current_group->id ) && !groups_is_user_banned( bp_loggedin_user_id(), $bp->groups->current_group->id ) ) {
    424424
    425425                // User wants to join a group that is not public.
    426                 if ( $bp->groups->current_group->status != 'public' ) {
     426                if ( bp_current_user_can( 'groups_join_group', array( 'group_id' => $bp->groups->current_group->id ) ) ) {
    427427                        if ( !groups_check_user_has_invite( bp_loggedin_user_id(), $bp->groups->current_group->id ) ) {
    428428                                bp_core_add_message( __( 'There was an error joining the group.', 'buddypress' ), 'error' );
    429429                                bp_core_redirect( bp_get_group_permalink( $bp->groups->current_group ) );
  • src/bp-groups/bp-groups-filters.php

    diff --git src/bp-groups/bp-groups-filters.php src/bp-groups/bp-groups-filters.php
    index 1071759..23c3e31 100644
    function bp_groups_disable_at_mention_notification_for_non_public_groups( $send, 
    313313                return $send;
    314314        }
    315315
    316         if ( 'groups' === $activity->component ) {
    317                 $group = groups_get_group( $activity->item_id );
    318                 if ( 'public' !== $group->status && ! groups_is_user_member( $user_id, $group->id ) ) {
    319                         $send = false;
    320                 }
     316        if ( 'groups' === $activity->component && ! bp_user_can( $user_id, 'groups_access_group', array( 'group_id' => $activity->item_id ) ) ) {
     317                $send = false;
    321318        }
    322319
    323320        return $send;
    function bp_groups_default_avatar( $avatar, $params ) { 
    345342
    346343        return $avatar;
    347344}
     345
     346/**
     347 * Filter the bp_user_can value to determine what the user can do
     348 * with regards to a specific group.
     349 *
     350 * @since 3.0.0
     351 *
     352 * @param bool   $retval     Whether or not the current user has the capability.
     353 * @param int    $user_id
     354 * @param string $capability The capability being checked for.
     355 * @param int    $site_id    Site ID. Defaults to the BP root blog.
     356 * @param array  $args       Array of extra arguments passed.
     357 *
     358 * @return bool
     359 */
     360function bp_groups_user_can_filter( $retval, $user_id, $capability, $site_id, $args ) {
     361        if ( empty( $args['group_id'] ) ) {
     362                $group_id = bp_get_current_group_id();
     363        } else {
     364                $group_id = (int) $args['group_id'];
     365        }
     366
     367        switch ( $capability ) {
     368                case 'groups_join_group':
     369                        // Return early if the user isn't logged in or the group ID is unknown.
     370                        if ( ! $user_id || ! $group_id ) {
     371                                break;
     372                        }
     373
     374                        // The group must allow joining, and the user should not currently be a member.
     375                        $group = groups_get_group( $group_id );
     376                        if ( 'public' == bp_get_group_status( $group )
     377                                && ! groups_is_user_member( $user_id, $group->id )
     378                                && ! groups_is_user_banned( $user_id, $group->id )
     379                        ) {
     380                                $retval = true;
     381                        }
     382
     383                        break;
     384
     385                case 'groups_request_membership':
     386                        // Return early if the user isn't logged in or the group ID is unknown.
     387                        if ( ! $user_id || ! $group_id ) {
     388                                break;
     389                        }
     390
     391                        /*
     392                        * The group must accept membership requests, and the user should not
     393                        * currently be a member, have an active request, or be banned.
     394                        */
     395                        $group = groups_get_group( $group_id );
     396                        if ( 'private' == bp_get_group_status( $group )
     397                                && ! groups_is_user_member( $user_id, $group->id )
     398                                && ! groups_check_for_membership_request( $user_id, $group->id )
     399                                && ! groups_is_user_banned( $user_id, $group->id )
     400                        ) {
     401                                $retval = true;
     402                        }
     403
     404                        break;
     405
     406                case 'groups_send_invitation':
     407                        // Return early if the user isn't logged in or the group ID is unknown.
     408                        if ( ! $user_id || ! $group_id ) {
     409                                break;
     410                        }
     411
     412                        /*
     413                        * The group must allow invitations, and the user should not
     414                        * currently be a member or be banned from the group.
     415                        */
     416                        $group = groups_get_group( $group_id );
     417                        // Users with the 'bp_moderate' cap can always send invitations.
     418                        if ( bp_user_can( $user_id, 'bp_moderate' ) ) {
     419                                $retval = true;
     420                        } else {
     421                                $invite_status = bp_group_get_invite_status( $group_id );
     422
     423                                switch ( $invite_status ) {
     424                                        case 'admins' :
     425                                                if ( groups_is_user_admin( $user_id, $group_id ) ) {
     426                                                        $retval = true;
     427                                                }
     428                                                break;
     429
     430                                        case 'mods' :
     431                                                if ( groups_is_user_mod( $user_id, $group_id ) || groups_is_user_admin( $user_id, $group_id ) ) {
     432                                                        $retval = true;
     433                                                }
     434                                                break;
     435
     436                                        case 'members' :
     437                                                if ( groups_is_user_member( $user_id, $group_id ) ) {
     438                                                        $retval = true;
     439                                                }
     440                                                break;
     441                                }
     442                        }
     443
     444                        break;
     445
     446                case 'groups_receive_invitation':
     447                        // Return early if the user isn't logged in or the group ID is unknown.
     448                        if ( ! $user_id || ! $group_id ) {
     449                                break;
     450                        }
     451
     452                        /*
     453                        * The group must allow invitations, and the user should not
     454                        * currently be a member or be banned from the group.
     455                        */
     456                        $group = groups_get_group( $group_id );
     457                        if ( in_array( bp_get_group_status( $group ), array( 'private', 'hidden' ) )
     458                                && ! groups_is_user_member( $user_id, $group->id )
     459                                && ! groups_is_user_banned( $user_id, $group->id )
     460                        ) {
     461                                $retval = true;
     462                        }
     463
     464                        break;
     465
     466                case 'groups_access_group':
     467                        // Return early if the group ID is unknown.
     468                        if ( ! $group_id ) {
     469                                break;
     470                        }
     471
     472                        $group = groups_get_group( $group_id );
     473
     474                        // If the check is for the logged-in user, use the BP_Groups_Group property.
     475                        if ( $user_id == bp_loggedin_user_id() ) {
     476                                $retval = $group->user_has_access;
     477
     478                        /*
     479                         * If the check is for a specified user who is not the logged-in user
     480                         * run the check manually.
     481                         */
     482                        } elseif ( 'public' == bp_get_group_status( $group ) || groups_is_user_member( $user_id, $group->id ) ) {
     483                                $retval = true;
     484                        }
     485
     486                        break;
     487
     488                case 'groups_see_group':
     489                        // Return early if the group ID is unknown.
     490                        if ( ! $group_id ) {
     491                                break;
     492                        }
     493
     494                        $group = groups_get_group( $group_id );
     495
     496                        // If the check is for the logged-in user, use the BP_Groups_Group property.
     497                        if ( $user_id == bp_loggedin_user_id() ) {
     498                                $retval = $group->is_visible;
     499
     500                        /*
     501                         * If the check is for a specified user who is not the logged-in user
     502                         * run the check manually.
     503                         */
     504                        } elseif ( 'hidden' != bp_get_group_status( $group ) || groups_is_user_member( $user_id, $group->id ) ) {
     505                                $retval = true;
     506                        }
     507
     508                        break;
     509        }
     510
     511        return $retval;
     512
     513}
     514add_filter( 'bp_user_can', 'bp_groups_user_can_filter', 10, 5 );
  • src/bp-groups/bp-groups-template.php

    diff --git src/bp-groups/bp-groups-template.php src/bp-groups/bp-groups-template.php
    index ac0d315..77a8a93 100644
    function bp_groups_user_can_send_invites( $group_id = 0, $user_id = 0 ) { 
    23572357        }
    23582358
    23592359        if ( $user_id ) {
    2360                 // Users with the 'bp_moderate' cap can always send invitations.
    2361                 if ( bp_user_can( $user_id, 'bp_moderate' ) ) {
    2362                         $can_send_invites = true;
    2363                 } else {
    2364                         $invite_status = bp_group_get_invite_status( $group_id );
    2365 
    2366                         switch ( $invite_status ) {
    2367                                 case 'admins' :
    2368                                         if ( groups_is_user_admin( $user_id, $group_id ) ) {
    2369                                                 $can_send_invites = true;
    2370                                         }
    2371                                         break;
    2372 
    2373                                 case 'mods' :
    2374                                         if ( groups_is_user_mod( $user_id, $group_id ) || groups_is_user_admin( $user_id, $group_id ) ) {
    2375                                                 $can_send_invites = true;
    2376                                         }
    2377                                         break;
    2378 
    2379                                 case 'members' :
    2380                                         if ( groups_is_user_member( $user_id, $group_id ) ) {
    2381                                                 $can_send_invites = true;
    2382                                         }
    2383                                         break;
    2384                         }
    2385                 }
     2360                $can_send_invites = bp_user_can( $user_id, 'groups_send_invitation', array( 'group_id' => $group_id ) );
    23862361        }
    23872362
    23882363        /**
  • src/bp-groups/classes/class-bp-groups-component.php

    diff --git src/bp-groups/classes/class-bp-groups-component.php src/bp-groups/classes/class-bp-groups-component.php
    index fc81d04..3e4c092 100644
    class BP_Groups_Component extends BP_Component { 
    544544                        // If this is a private group, and the user is not a
    545545                        // member and does not have an outstanding invitation,
    546546                        // show a "Request Membership" nav item.
    547                         if ( is_user_logged_in() &&
    548                                  ! $this->current_group->is_member &&
    549                                  ! groups_check_for_membership_request( bp_loggedin_user_id(), $this->current_group->id ) &&
    550                                  $this->current_group->status == 'private' &&
    551                                  ! groups_check_user_has_invite( bp_loggedin_user_id(), $this->current_group->id )
    552                                 ) {
     547                        if ( bp_current_user_can( 'groups_request_membership', array( 'group_id' => $this->current_group->id ) ) ) {
    553548
    554549                                $sub_nav[] = array(
    555550                                        'name'            => _x( 'Request Membership','Group screen nav', 'buddypress' ),
  • src/bp-templates/bp-legacy/buddypress-functions.php

    diff --git src/bp-templates/bp-legacy/buddypress-functions.php src/bp-templates/bp-legacy/buddypress-functions.php
    index 621eacd..13d2663 100644
    function bp_legacy_theme_ajax_joinleave_group() { 
    14921492                return;
    14931493
    14941494        if ( ! groups_is_user_member( bp_loggedin_user_id(), $group->id ) ) {
    1495                 if ( 'public' == $group->status ) {
     1495                if ( bp_current_user_can( 'groups_join_group', array( 'group_id' => $group->id ) ) ) {
    14961496                        check_ajax_referer( 'groups_join_group' );
    14971497
    14981498                        if ( ! groups_join_group( $group->id ) ) {
    function bp_legacy_theme_ajax_joinleave_group() { 
    15011501                                echo '<a id="group-' . esc_attr( $group->id ) . '" class="group-button leave-group" rel="leave" href="' . wp_nonce_url( bp_get_group_permalink( $group ) . 'leave-group', 'groups_leave_group' ) . '">' . __( 'Leave Group', 'buddypress' ) . '</a>';
    15021502                        }
    15031503
    1504                 } elseif ( 'private' == $group->status ) {
     1504                } elseif ( bp_current_user_can( 'groups_request_membership', array( 'group_id' => $group->id ) ) ) {
    15051505
    15061506                        // If the user has already been invited, then this is
    15071507                        // an Accept Invitation button.
    function bp_legacy_theme_ajax_joinleave_group() { 
    15311531
    15321532                if ( ! groups_leave_group( $group->id ) ) {
    15331533                        _e( 'Error leaving group', 'buddypress' );
    1534                 } elseif ( 'public' == $group->status ) {
     1534                } elseif ( bp_current_user_can( 'groups_join_group', array( 'group_id' => $group->id ) ) ) {
    15351535                        echo '<a id="group-' . esc_attr( $group->id ) . '" class="group-button join-group" rel="join" href="' . wp_nonce_url( bp_get_group_permalink( $group ) . 'join', 'groups_join_group' ) . '">' . __( 'Join Group', 'buddypress' ) . '</a>';
    1536                 } elseif ( 'private' == $group->status ) {
     1536                } elseif ( bp_current_user_can( 'groups_request_membership', array( 'group_id' => $group->id ) ) ) {
    15371537                        echo '<a id="group-' . esc_attr( $group->id ) . '" class="group-button request-membership" rel="join" href="' . wp_nonce_url( bp_get_group_permalink( $group ) . 'request-membership', 'groups_request_membership' ) . '">' . __( 'Request Membership', 'buddypress' ) . '</a>';
    15381538                }
    15391539        }
  • new file tests/phpunit/testcases/groups/user_can.php

    diff --git tests/phpunit/testcases/groups/user_can.php tests/phpunit/testcases/groups/user_can.php
    new file mode 100644
    index 0000000..96bb4b5
    - +  
     1<?php
     2
     3/**
     4 * @group bp_user_can
     5 */
     6class BP_Tests_Groups_User_Can_Filter extends BP_UnitTestCase {
     7
     8        public function test_user_can_groups_join_group_public() {
     9                $g1 = $this->factory->group->create( array(
     10                        'status'      => 'public'
     11                ) );
     12                $u1 = $this->factory->user->create();
     13
     14                $this->assertTrue( bp_user_can( $u1, 'groups_join_group', array( 'group_id' => $g1 ) ) );
     15        }
     16
     17        public function test_user_can_groups_join_group_public_already_member() {
     18                $g1 = $this->factory->group->create( array(
     19                        'status'      => 'public'
     20                ) );
     21                $u1 = $this->factory->user->create();
     22                $this->add_user_to_group( $u1, $g1 );
     23
     24                $this->assertFalse( bp_user_can( $u1, 'groups_join_group', array( 'group_id' => $g1 ) ) );
     25        }
     26
     27        public function test_user_can_groups_join_group_private() {
     28                $g1 = $this->factory->group->create( array(
     29                        'status'      => 'private'
     30                ) );
     31                $u1 = $this->factory->user->create();
     32
     33                $this->assertFalse( bp_user_can( $u1, 'groups_join_group', array( 'group_id' => $g1 ) ) );
     34        }
     35
     36        public function test_user_can_groups_join_group_banned() {
     37                $g1 = $this->factory->group->create( array(
     38                        'status'      => 'public'
     39                ) );
     40                $u1 = $this->factory->user->create();
     41                $this->add_user_to_group( $u1, $g1 );
     42
     43                buddypress()->is_item_admin = true;
     44                groups_ban_member( $u1, $g1 );
     45
     46                $this->assertFalse( bp_user_can( $u1, 'groups_join_group', array( 'group_id' => $g1 ) ) );
     47        }
     48
     49        public function test_user_can_groups_request_membership_public() {
     50                $g1 = $this->factory->group->create( array(
     51                        'status'      => 'public'
     52                ) );
     53                $u1 = $this->factory->user->create();
     54
     55                $this->assertFalse( bp_user_can( $u1, 'groups_request_membership', array( 'group_id' => $g1 ) ) );
     56        }
     57
     58        public function test_user_can_groups_request_membership_private() {
     59                $g1 = $this->factory->group->create( array(
     60                        'status'      => 'private'
     61                ) );
     62                $u1 = $this->factory->user->create();
     63
     64                $this->assertTrue( bp_user_can( $u1, 'groups_request_membership', array( 'group_id' => $g1 ) ) );
     65        }
     66
     67        public function test_user_can_groups_request_membership_hidden() {
     68                $g1 = $this->factory->group->create( array(
     69                        'status'      => 'hidden'
     70                ) );
     71                $u1 = $this->factory->user->create();
     72
     73                $this->assertFalse( bp_user_can( $u1, 'groups_request_membership', array( 'group_id' => $g1 ) ) );
     74        }
     75
     76        public function test_user_can_groups_request_membership_private_already_member() {
     77                $g1 = $this->factory->group->create( array(
     78                        'status'      => 'private'
     79                ) );
     80                $u1 = $this->factory->user->create();
     81                $this->add_user_to_group( $u1, $g1 );
     82
     83                $this->assertFalse( bp_user_can( $u1, 'groups_request_membership', array( 'group_id' => $g1 ) ) );
     84        }
     85
     86        public function test_user_can_groups_request_membership_private_already_requested() {
     87                $g1 = $this->factory->group->create( array(
     88                        'status'      => 'private'
     89                ) );
     90                $u1 = $this->factory->user->create();
     91                groups_send_membership_request( $u1, $g1 );
     92
     93                $this->assertFalse( bp_user_can( $u1, 'groups_request_membership', array( 'group_id' => $g1 ) ) );
     94        }
     95
     96        public function test_user_can_groups_request_membership_banned() {
     97                $g1 = $this->factory->group->create( array(
     98                        'status'      => 'private'
     99                ) );
     100                $u1 = $this->factory->user->create();
     101                $this->add_user_to_group( $u1, $g1 );
     102
     103                buddypress()->is_item_admin = true;
     104                groups_ban_member( $u1, $g1 );
     105
     106                $this->assertFalse( bp_user_can( $u1, 'groups_request_membership', array( 'group_id' => $g1 ) ) );
     107        }
     108
     109        public function test_user_can_groups_receive_invitation_public() {
     110                $g1 = $this->factory->group->create( array(
     111                        'status'      => 'public'
     112                ) );
     113                $u1 = $this->factory->user->create();
     114
     115                $this->assertFalse( bp_user_can( $u1, 'groups_receive_invitation', array( 'group_id' => $g1 ) ) );
     116        }
     117
     118        public function test_user_can_groups_receive_invitation_private() {
     119                $g1 = $this->factory->group->create( array(
     120                        'status'      => 'private'
     121                ) );
     122                $u1 = $this->factory->user->create();
     123
     124                $this->assertTrue( bp_user_can( $u1, 'groups_receive_invitation', array( 'group_id' => $g1 ) ) );
     125        }
     126
     127        public function test_user_can_groups_receive_invitation_private_already_member() {
     128                $g1 = $this->factory->group->create( array(
     129                        'status'      => 'private'
     130                ) );
     131                $u1 = $this->factory->user->create();
     132                $this->add_user_to_group( $u1, $g1 );
     133
     134                $this->assertFalse( bp_user_can( $u1, 'groups_receive_invitation', array( 'group_id' => $g1 ) ) );
     135        }
     136
     137        public function test_user_can_groups_receive_invitation_hidden() {
     138                $g1 = $this->factory->group->create( array(
     139                        'status'      => 'hidden'
     140                ) );
     141                $u1 = $this->factory->user->create();
     142
     143                $this->assertTrue( bp_user_can( $u1, 'groups_receive_invitation', array( 'group_id' => $g1 ) ) );
     144        }
     145
     146        public function test_user_can_groups_receive_invitation_private_banned() {
     147                $g1 = $this->factory->group->create( array(
     148                        'status'      => 'private'
     149                ) );
     150                $u1 = $this->factory->user->create();
     151                $this->add_user_to_group( $u1, $g1 );
     152
     153                buddypress()->is_item_admin = true;
     154                groups_ban_member( $u1, $g1 );
     155
     156                $this->assertFalse( bp_user_can( $u1, 'groups_receive_invitation', array( 'group_id' => $g1 ) ) );
     157        }
     158
     159        public function test_user_can_groups_send_invitation_public() {
     160                $g1 = $this->factory->group->create( array(
     161                        'status'      => 'public'
     162                ) );
     163                $u1 = $this->factory->user->create();
     164
     165                $this->assertFalse( bp_user_can( $u1, 'groups_send_invitation', array( 'group_id' => $g1 ) ) );
     166        }
     167
     168        public function test_user_can_groups_send_invitation_private() {
     169                $g1 = $this->factory->group->create( array(
     170                        'status'      => 'private'
     171                ) );
     172                $u1 = $this->factory->user->create();
     173
     174                $this->assertFalse( bp_user_can( $u1, 'groups_send_invitation', array( 'group_id' => $g1 ) ) );
     175        }
     176
     177        public function test_user_can_groups_send_invitation_private_member() {
     178                $g1 = $this->factory->group->create( array(
     179                        'status'      => 'private',
     180
     181                ) );
     182                groups_update_groupmeta( $g1, 'invite_status', 'members' );
     183                $u1 = $this->factory->user->create();
     184                $this->add_user_to_group( $u1, $g1 );
     185
     186                $this->assertTrue( bp_user_can( $u1, 'groups_send_invitation', array( 'group_id' => $g1 ) ) );
     187        }
     188
     189        public function test_user_can_groups_send_invitation_hidden() {
     190                $g1 = $this->factory->group->create( array(
     191                        'status'      => 'hidden'
     192                ) );
     193                $u1 = $this->factory->user->create();
     194                $u1 = $this->factory->user->create();
     195                $this->add_user_to_group( $u1, $g1 );
     196
     197                $this->assertTrue( bp_user_can( $u1, 'groups_send_invitation', array( 'group_id' => $g1 ) ) );
     198        }
     199
     200        public function test_user_can_groups_send_invitation_private_banned() {
     201                $g1 = $this->factory->group->create( array(
     202                        'status'      => 'private'
     203                ) );
     204                groups_update_groupmeta( $g1, 'invite_status', 'members' );
     205                $u1 = $this->factory->user->create();
     206                $this->add_user_to_group( $u1, $g1 );
     207
     208                buddypress()->is_item_admin = true;
     209                groups_ban_member( $u1, $g1 );
     210
     211                $this->assertFalse( bp_user_can( $u1, 'groups_send_invitation', array( 'group_id' => $g1 ) ) );
     212        }
     213
     214        public function test_user_can_groups_access_group_public() {
     215                $g1 = $this->factory->group->create( array(
     216                        'status'      => 'public'
     217                ) );
     218                $u1 = $this->factory->user->create();
     219
     220                $this->assertTrue( bp_user_can( $u1, 'groups_access_group', array( 'group_id' => $g1 ) ) );
     221        }
     222
     223        public function test_user_can_groups_access_group_private() {
     224                $g1 = $this->factory->group->create( array(
     225                        'status'      => 'private'
     226                ) );
     227                $u1 = $this->factory->user->create();
     228
     229                $this->assertFalse( bp_user_can( $u1, 'groups_access_group', array( 'group_id' => $g1 ) ) );
     230        }
     231
     232        public function test_user_can_groups_access_group_private_logged_in_user() {
     233                $g1 = $this->factory->group->create( array(
     234                        'status'      => 'private'
     235                ) );
     236                $u1 = $this->factory->user->create();
     237                $old_user = get_current_user_id();
     238                $this->set_current_user( $u1 );
     239
     240                $this->assertFalse( bp_current_user_can( 'groups_access_group', array( 'group_id' => $g1 ) ) );
     241
     242                $this->set_current_user( $old_user );
     243        }
     244
     245        public function test_user_can_groups_access_group_private_member() {
     246                $g1 = $this->factory->group->create( array(
     247                        'status'      => 'private'
     248                ) );
     249                $u1 = $this->factory->user->create();
     250                $this->add_user_to_group( $u1, $g1 );
     251
     252                $this->assertTrue( bp_user_can( $u1, 'groups_access_group', array( 'group_id' => $g1 ) ) );
     253        }
     254
     255        public function test_user_can_groups_access_group_hidden() {
     256                $g1 = $this->factory->group->create( array(
     257                        'status'      => 'hidden'
     258                ) );
     259                $u1 = $this->factory->user->create();
     260
     261                $this->assertFalse( bp_user_can( $u1, 'groups_access_group', array( 'group_id' => $g1 ) ) );
     262        }
     263
     264        public function test_user_can_groups_access_group_hidden_member() {
     265                $g1 = $this->factory->group->create( array(
     266                        'status'      => 'hidden'
     267                ) );
     268                $u1 = $this->factory->user->create();
     269                $this->add_user_to_group( $u1, $g1 );
     270
     271                $this->assertTrue( bp_user_can( $u1, 'groups_access_group', array( 'group_id' => $g1 ) ) );
     272        }
     273
     274        public function test_user_can_groups_access_group_hidden_logged_in_user() {
     275                $g1 = $this->factory->group->create( array(
     276                        'status'      => 'hidden'
     277                ) );
     278                $u1 = $this->factory->user->create();
     279                $old_user = get_current_user_id();
     280                $this->set_current_user( $u1 );
     281
     282                $this->assertFalse( bp_current_user_can( 'groups_access_group', array( 'group_id' => $g1 ) ) );
     283
     284                $this->set_current_user( $old_user );
     285        }
     286
     287        public function test_user_can_groups_see_group_public() {
     288                $g1 = $this->factory->group->create( array(
     289                        'status'      => 'public'
     290                ) );
     291                $u1 = $this->factory->user->create();
     292
     293                $this->assertTrue( bp_user_can( $u1, 'groups_see_group', array( 'group_id' => $g1 ) ) );
     294        }
     295
     296        public function test_user_can_groups_see_group_private() {
     297                $g1 = $this->factory->group->create( array(
     298                        'status'      => 'private'
     299                ) );
     300                $u1 = $this->factory->user->create();
     301
     302                $this->assertTrue( bp_user_can( $u1, 'groups_see_group', array( 'group_id' => $g1 ) ) );
     303        }
     304
     305        public function test_user_can_groups_see_group_private_logged_in_user() {
     306                $g1 = $this->factory->group->create( array(
     307                        'status'      => 'private'
     308                ) );
     309                $u1 = $this->factory->user->create();
     310                $old_user = get_current_user_id();
     311                $this->set_current_user( $u1 );
     312
     313                $this->assertTrue( bp_current_user_can( 'groups_see_group', array( 'group_id' => $g1 ) ) );
     314
     315                $this->set_current_user( $old_user );
     316        }
     317
     318        public function test_user_can_groups_see_group_hidden() {
     319                $g1 = $this->factory->group->create( array(
     320                        'status'      => 'hidden'
     321                ) );
     322                $u1 = $this->factory->user->create();
     323
     324                $this->assertFalse( bp_user_can( $u1, 'groups_see_group', array( 'group_id' => $g1 ) ) );
     325        }
     326
     327        public function test_user_can_groups_see_group_hidden_member() {
     328                $g1 = $this->factory->group->create( array(
     329                        'status'      => 'hidden'
     330                ) );
     331                $u1 = $this->factory->user->create();
     332                $this->add_user_to_group( $u1, $g1 );
     333
     334                $this->assertTrue( bp_user_can( $u1, 'groups_see_group', array( 'group_id' => $g1 ) ) );
     335        }
     336
     337        public function test_user_can_groups_see_group_hidden_logged_in_user() {
     338                $g1 = $this->factory->group->create( array(
     339                        'status'      => 'hidden'
     340                ) );
     341                $u1 = $this->factory->user->create();
     342                $old_user = get_current_user_id();
     343                $this->set_current_user( $u1 );
     344
     345                $this->assertFalse( bp_current_user_can( 'groups_see_group', array( 'group_id' => $g1 ) ) );
     346
     347                $this->set_current_user( $old_user );
     348        }
     349
     350}