Skip to:
Content

BuddyPress.org

Ticket #6280: 6280.diff

File 6280.diff, 20.7 KB (added by boonebgorges, 10 years ago)

  • src/bp-core/bp-core-cache.php 

    diff --git a/src/bp-core/bp-core-cache.php b/src/bp-core/bp-core-cache.php
index 5ee7de4..05e3625 100644
    a b function bp_core_clear_directory_pages_cache_page_edit( $post_id ) { 
    6969                return;
    7070        }
    7171
    72         $page_ids = bp_core_get_directory_page_ids();
     72        $page_ids = bp_core_get_directory_page_ids( 'all' );
    7373
    7474        if ( ! in_array( $post_id, (array) $page_ids ) ) {
    7575                return;

  • src/bp-core/bp-core-functions.php 

    diff --git a/src/bp-core/bp-core-functions.php b/src/bp-core/bp-core-functions.php
index 0671b49..25bde9d 100644
    a b function bp_core_get_packaged_component_ids() { 
    418418 *
    419419 * @since BuddyPress (1.5.0)
    420420 *
     421 * @param string $status 'active' to return only pages associated with active components, 'all' to return all saved
     422 *                       pages. When running save routines, use 'all' to avoid removing data related to inactive
     423 *                       components. Default: 'active'.
    421424 * @return array|string An array of page IDs, keyed by component names, or an
    422  *         empty string if the list is not found.
     425 *                      empty string if the list is not found.
    423426 */
    424 function bp_core_get_directory_page_ids() {
     427function bp_core_get_directory_page_ids( $status = 'active' ) {
    425428        $page_ids = bp_get_option( 'bp-pages' );
    426429
    427430        // Ensure that empty indexes are unset. Should only matter in edge cases
    … … function bp_core_get_directory_page_ids() { 
    436439                                continue;
    437440                        }
    438441
    439                         if ( ! bp_is_active( $component_name ) || 'trash' == get_post_status( $page_id ) ) {
     442                        // Trashed pages should not appear in results.
     443                        if ( 'trash' == get_post_status( $page_id ) ) {
     444                                unset( $page_ids[ $component_name ] );
     445
     446                        }
     447
     448                        // Remove inactive component pages, if required.
     449                        if ( 'active' === $status && ! bp_is_active( $component_name ) ) {
    440450                                unset( $page_ids[ $component_name ] );
    441451                        }
    442452                }
    … … function bp_core_add_page_mappings( $components, $existing = 'keep' ) { 
    548558                switch_to_blog( bp_get_root_blog_id() );
    549559        }
    550560
    551         $pages = bp_core_get_directory_page_ids();
     561        $pages = bp_core_get_directory_page_ids( 'all' );
    552562
    553563        // Delete any existing pages
    554564        if ( 'delete' === $existing ) {
    … … function bp_core_on_directory_page_delete( $post_id ) { 
    639649                return;
    640650        }
    641651
    642         $page_ids       = bp_core_get_directory_page_ids();
     652        $page_ids       = bp_core_get_directory_page_ids( 'all' );
    643653        $component_name = array_search( $post_id, $page_ids );
    644654
    645655        if ( ! empty( $component_name ) ) {
    … … function bp_core_create_root_component_page() { 
    745755                ) );
    746756        }
    747757
    748         $page_ids = array_merge( (array) $new_page_ids, (array) bp_core_get_directory_page_ids() );
     758        $page_ids = array_merge( (array) $new_page_ids, (array) bp_core_get_directory_page_ids( 'all' ) );
    749759        bp_core_update_directory_page_ids( $page_ids );
    750760}
    751761

  • tests/phpunit/testcases/core/functions.php 

    diff --git a/tests/phpunit/testcases/core/functions.php b/tests/phpunit/testcases/core/functions.php
index 68679ad..fd93c81 100644
    a b class BP_Tests_Core_Functions extends BP_UnitTestCase { 
    452452        }
    453453
    454454        /**
    455          * @group bp_core_get_directory_page_ids
    456          */
    457         public function test_bp_core_get_directory_page_ids_on_directory_page_to_trash() {
    458                 $old_page_ids = bp_core_get_directory_page_ids();
    459 
    460                 // Grab the and remove the first page.
    461                 foreach ( $old_page_ids as $component => $page_id ) {
    462                         $p = $page_id;
    463                         unset( $old_page_ids[ $component ] );
    464                         break;
    465                 }
    466 
    467                 // Move page to trash.
    468                 wp_delete_post( $p, false );
    469 
    470                 $new_page_ids = bp_core_get_directory_page_ids();
    471 
    472                 $this->assertEquals( $old_page_ids, $new_page_ids );
    473         }
    474 
    475         /**
    476          * @group bp_core_get_directory_page_ids
    477          */
    478         public function test_bp_core_get_directory_page_ids_on_directory_page_delete() {
    479                 $old_page_ids = bp_core_get_directory_page_ids();
    480 
    481                 // Grab the and remove the first page.
    482                 foreach ( $old_page_ids as $component => $page_id ) {
    483                         $p = $page_id;
    484                         unset( $old_page_ids[ $component ] );
    485                         break;
    486                 }
    487 
    488                 // Force delete page.
    489                 wp_delete_post( $p, true );
    490 
    491                 $new_page_ids = bp_core_get_directory_page_ids();
    492 
    493                 $this->assertEquals( $old_page_ids, $new_page_ids );
    494         }
    495 
    496         /**
    497          * @group bp_core_get_directory_page_ids
    498          */
    499         public function test_bp_core_get_directory_page_ids_on_non_directory_page_delete() {
    500                 $old_page_ids = bp_core_get_directory_page_ids();
    501 
    502                 $p = $this->factory->post->create( array(
    503                         'post_status' => 'publish',
    504                         'post_type' => 'page',
    505                 ) );
    506 
    507                 // Force delete page.
    508                 wp_delete_post( $p, true );
    509 
    510                 $new_page_ids = bp_core_get_directory_page_ids();
    511 
    512                 $this->assertEquals( $old_page_ids, $new_page_ids );
    513         }
    514 
    515         /**
    516          * @group bp_core_get_directory_page_ids
    517          */
    518         public function test_bp_core_get_directory_page_ids_non_active_component() {
    519                 $old_page_ids = bp_core_get_directory_page_ids();
    520                 $bp = buddypress();
    521 
    522                 // Grab the and remove the first page.
    523                 foreach ( $old_page_ids as $component => $page_id ) {
    524                         $p = $page_id;
    525                         $c = $component;
    526                         unset( $old_page_ids[ $component ] );
    527                         break;
    528                 }
    529 
    530                 // Deactivate component.
    531                 unset( $bp->active_components[ $c ] );
    532 
    533                 $new_page_ids = bp_core_get_directory_page_ids();
    534 
    535                 // Restore components.
    536                 $bp->active_components[ $c ] = 1;
    537 
    538                 $this->assertEquals( $old_page_ids, $new_page_ids );
    539         }
    540 
    541         /**
    542          * @group bp_core_get_directory_page_ids
    543          */
    544         public function test_bp_core_get_directory_page_ids_should_contain_register_and_activet_pages_when_registration_is_open() {
    545                 add_filter( 'bp_get_signup_allowed', '__return_true', 999 );
    546 
    547                 $ac = buddypress()->active_components;
    548                 bp_core_add_page_mappings( array_keys( $ac ) );
    549 
    550                 $page_ids = bp_core_get_directory_page_ids();
    551                 $page_names = array_keys( $page_ids );
    552 
    553                 $this->assertContains( 'register', $page_names );
    554                 $this->assertContains( 'activate', $page_names );
    555 
    556                 remove_filter( 'bp_get_signup_allowed', '__return_true', 999 );
    557         }
    558 
    559         /**
    560          * @group bp_core_get_directory_page_ids
    561          */
    562         public function test_bp_core_get_directory_page_ids_should_not_contain_register_and_activet_pages_when_registration_is_closed() {
    563 
    564                 // Make sure the pages exist, to verify they're filtered out.
    565                 add_filter( 'bp_get_signup_allowed', '__return_true', 999 );
    566                 $ac = buddypress()->active_components;
    567                 bp_core_add_page_mappings( array_keys( $ac ) );
    568                 remove_filter( 'bp_get_signup_allowed', '__return_true', 999 );
    569 
    570                 // Get page ids
    571                 $page_ids = bp_core_get_directory_page_ids();
    572 
    573                 // Need to delete these pages as previously created.
    574                 wp_delete_post( $page_ids['register'], true );
    575                 wp_delete_post( $page_ids['activate'], true );
    576 
    577                 add_filter( 'bp_get_signup_allowed', '__return_false', 999 );
    578                 bp_core_add_page_mappings( array_keys( $ac ) );
    579                 $page_ids = bp_core_get_directory_page_ids();
    580                 remove_filter( 'bp_get_signup_allowed', '__return_false', 999 );
    581 
    582                 $page_names = array_keys( $page_ids );
    583 
    584                 $this->assertNotContains( 'register', $page_names );
    585                 $this->assertNotContains( 'activate', $page_names );
    586         }
    587 
    588         /**
    589          * @group bp_core_get_directory_pages
    590          */
    591         public function test_bp_core_get_directory_pages_register_activate_page_created_signups_allowed() {
    592                 add_filter( 'bp_get_signup_allowed', '__return_true', 999 );
    593 
    594                 $ac = buddypress()->active_components;
    595                 bp_core_add_page_mappings( array_keys( $ac ) );
    596                 $directory_pages = bp_core_get_directory_pages();
    597 
    598                 remove_filter( 'bp_get_signup_allowed', '__return_true', 999 );
    599 
    600                 $this->assertTrue( isset( $directory_pages->register ) );
    601                 $this->assertTrue( isset( $directory_pages->activate ) );
    602 
    603                 $r = get_post( $directory_pages->register->id );
    604                 $this->assertTrue( 'publish' == $r->post_status );
    605 
    606                 $a = get_post( $directory_pages->activate->id );
    607                 $this->assertTrue( 'publish' == $a->post_status );
    608         }
    609 
    610         /**
    611          * @group bp_core_get_directory_pages
    612          */
    613         public function test_bp_core_get_directory_pages_register_activate_page_notcreated_signups_allowed() {
    614                 add_filter( 'bp_get_signup_allowed', '__return_false', 999 );
    615 
    616                 $ac = buddypress()->active_components;
    617                 bp_core_add_page_mappings( array_keys( $ac ) );
    618 
    619                 remove_filter( 'bp_get_signup_allowed', '__return_false', 999 );
    620 
    621                 add_filter( 'bp_get_signup_allowed', '__return_true', 999 );
    622 
    623                 $directory_pages = bp_core_get_directory_pages();
    624 
    625                 remove_filter( 'bp_get_signup_allowed', '__return_true', 999 );
    626 
    627                 $this->assertFalse( isset( $directory_pages->register ) );
    628                 $this->assertFalse( isset( $directory_pages->activate ) );
    629         }
    630 
    631         /**
    632          * @group bp_core_get_directory_pages
    633          */
    634         public function test_bp_core_get_directory_pages_register_activate_page_created_signups_notallowed() {
    635                 add_filter( 'bp_get_signup_allowed', '__return_true', 999 );
    636 
    637                 $ac = buddypress()->active_components;
    638                 bp_core_add_page_mappings( array_keys( $ac ) );
    639 
    640                 remove_filter( 'bp_get_signup_allowed', '__return_true', 999 );
    641 
    642                 add_filter( 'bp_get_signup_allowed', '__return_false', 999 );
    643 
    644                 $directory_pages = bp_core_get_directory_pages();
    645 
    646                 remove_filter( 'bp_get_signup_allowed', '__return_false', 999 );
    647 
    648                 $this->assertTrue( isset( $directory_pages->register ) );
    649                 $this->assertTrue( isset( $directory_pages->activate ) );
    650 
    651                 $r = get_post( $directory_pages->register->id );
    652                 $this->assertTrue( 'publish' == $r->post_status );
    653 
    654                 $a = get_post( $directory_pages->activate->id );
    655                 $this->assertTrue( 'publish' == $a->post_status );
    656         }
    657 
    658         /**
    659          * @group bp_core_get_directory_pages
    660          */
    661         public function test_bp_core_get_directory_pages_register_activate_page_notcreated_signups_notallowed() {
    662 
    663                 add_filter( 'bp_get_signup_allowed', '__return_false', 999 );
    664 
    665                 $ac = buddypress()->active_components;
    666                 bp_core_add_page_mappings( array_keys( $ac ) );
    667                 $directory_pages = bp_core_get_directory_pages();
    668 
    669                 remove_filter( 'bp_get_signup_allowed', '__return_false', 999 );
    670 
    671                 $this->assertFalse( isset( $directory_pages->register ) );
    672                 $this->assertFalse( isset( $directory_pages->activate ) );
    673         }
    674 
    675         /**
    676          * @group bp_core_get_directory_pages
    677          */
    678         public function test_bp_core_get_directory_pages_pages_settings_update() {
    679                 // Set the cache
    680                 $pages = bp_core_get_directory_pages();
    681 
    682                 // Mess with it but put it back
    683                 $v = bp_get_option( 'bp-pages' );
    684                 bp_update_option( 'bp-pages', 'foo' );
    685 
    686                 $this->assertFalse( wp_cache_get( 'directory_pages', 'bp' ) );
    687 
    688                 bp_update_option( 'bp-pages', $v );
    689         }
    690 
    691         /**
    692          * @group bp_core_get_directory_pages
    693          */
    694         public function test_bp_core_get_directory_pages_multisite_delete_post_with_same_bp_page_id() {
    695                 if ( ! is_multisite() ) {
    696                         return;
    697                 }
    698 
    699                 $dir_pages = bp_core_get_directory_pages();
    700 
    701                 // create a blog
    702                 $u = $this->factory->user->create();
    703                 $b1 = $this->factory->blog->create( array( 'user_id' => $u ) );
    704 
    705                 // switch to blog and create some dummy posts until we reach a post ID that
    706                 // matches our BP activity page ID
    707                 switch_to_blog( $b1 );
    708                 $p = $this->factory->post->create();
    709                 while( $p <= $dir_pages->activity->id ) {
    710                         $p = $this->factory->post->create();
    711                 }
    712 
    713                 // delete the post that matches the BP activity page ID on this sub-site
    714                 wp_delete_post( $dir_pages->activity->id, true );
    715 
    716                 // restore blog
    717                 restore_current_blog();
    718 
    719                 // refetch BP directory pages
    720                 $dir_pages = bp_core_get_directory_pages();
    721 
    722                 // Now verify that our BP activity page was not wiped out
    723                 $this->assertNotEmpty( $dir_pages->activity );
    724         }
    725 
    726         /**
    727455         * @group bp_core_get_root_options
    728456         */
    729457        public function test_bp_core_get_root_options_cache_invalidate() {

  • new file tests/phpunit/testcases/core/functions/bpCoreGetDirectoryPageIds.php 

    diff --git a/tests/phpunit/testcases/core/functions/bpCoreGetDirectoryPageIds.php b/tests/phpunit/testcases/core/functions/bpCoreGetDirectoryPageIds.php
new file mode 100644
index 0000000..aa1ca33
    - +  
     1<?php
     2
     3/**
     4 * @group core
     5 * @covers ::bp_core_get_directory_page_ids
     6 */
     7class BP_Tests_Core_Functions_BpCoreGetDirectoryPageIds extends BP_UnitTestCase {
     8        public function test_bp_core_get_directory_page_ids_on_directory_page_to_trash() {
     9                $old_page_ids = bp_core_get_directory_page_ids();
     10
     11                // Grab the and remove the first page.
     12                foreach ( $old_page_ids as $component => $page_id ) {
     13                        $p = $page_id;
     14                        unset( $old_page_ids[ $component ] );
     15                        break;
     16                }
     17
     18                // Move page to trash.
     19                wp_delete_post( $p, false );
     20
     21                $new_page_ids = bp_core_get_directory_page_ids();
     22
     23                $this->assertEquals( $old_page_ids, $new_page_ids );
     24        }
     25
     26        public function test_bp_core_get_directory_page_ids_on_directory_page_delete() {
     27                $old_page_ids = bp_core_get_directory_page_ids();
     28
     29                // Grab the and remove the first page.
     30                foreach ( $old_page_ids as $component => $page_id ) {
     31                        $p = $page_id;
     32                        unset( $old_page_ids[ $component ] );
     33                        break;
     34                }
     35
     36                // Force delete page.
     37                wp_delete_post( $p, true );
     38
     39                $new_page_ids = bp_core_get_directory_page_ids();
     40
     41                $this->assertEquals( $old_page_ids, $new_page_ids );
     42        }
     43
     44        public function test_bp_core_get_directory_page_ids_on_non_directory_page_delete() {
     45                $old_page_ids = bp_core_get_directory_page_ids();
     46
     47                $p = $this->factory->post->create( array(
     48                        'post_status' => 'publish',
     49                        'post_type' => 'page',
     50                ) );
     51
     52                // Force delete page.
     53                wp_delete_post( $p, true );
     54
     55                $new_page_ids = bp_core_get_directory_page_ids();
     56
     57                $this->assertEquals( $old_page_ids, $new_page_ids );
     58        }
     59
     60        public function test_bp_core_get_directory_page_ids_non_active_component() {
     61                $old_page_ids = bp_core_get_directory_page_ids();
     62                $bp = buddypress();
     63
     64                // Grab the and remove the first page.
     65                foreach ( $old_page_ids as $component => $page_id ) {
     66                        $p = $page_id;
     67                        $c = $component;
     68                        unset( $old_page_ids[ $component ] );
     69                        break;
     70                }
     71
     72                // Deactivate component.
     73                unset( $bp->active_components[ $c ] );
     74
     75                $new_page_ids = bp_core_get_directory_page_ids();
     76
     77                // Restore components.
     78                $bp->active_components[ $c ] = 1;
     79
     80                $this->assertEquals( $old_page_ids, $new_page_ids );
     81        }
     82
     83        /**
     84         * @ticket BP6280
     85         */
     86        public function test_inactive_components_should_not_be_removed_if_status_is_all() {
     87                $old_page_ids = bp_core_get_directory_page_ids( 'all' );
     88
     89                $page_ids = $old_page_ids;
     90                $page_ids['foo'] = 12345;
     91
     92                bp_core_update_directory_page_ids( $page_ids );
     93                $found = bp_core_get_directory_page_ids( 'all' );
     94
     95                $this->assertEquals( 12345, $found['foo'] );
     96        }
     97
     98        /**
     99         * @ticket BP6280
     100         */
     101        public function test_inactive_components_should_be_removed_if_status_is_active() {
     102                $old_page_ids = bp_core_get_directory_page_ids( 'all' );
     103
     104                $page_ids = $old_page_ids;
     105                $page_ids['foo'] = 12345;
     106
     107                bp_core_update_directory_page_ids( $page_ids );
     108                $found = bp_core_get_directory_page_ids( 'active' );
     109
     110                $this->assertFalse( isset( $found['foo'] ) );
     111        }
     112
     113        /**
     114         * @ticket BP6280
     115         */
     116        public function test_inactive_components_should_be_removed_if_status_is_unspecified() {
     117                $old_page_ids = bp_core_get_directory_page_ids( 'all' );
     118
     119                $page_ids = $old_page_ids;
     120                $page_ids['foo'] = 12345;
     121
     122                bp_core_update_directory_page_ids( $page_ids );
     123                $found = bp_core_get_directory_page_ids( 'active' );
     124
     125                $this->assertFalse( isset( $found['foo'] ) );
     126        }
     127
     128        public function test_bp_core_get_directory_page_ids_should_contain_register_and_activet_pages_when_registration_is_open() {
     129                add_filter( 'bp_get_signup_allowed', '__return_true', 999 );
     130
     131                $ac = buddypress()->active_components;
     132                bp_core_add_page_mappings( array_keys( $ac ) );
     133
     134                $page_ids = bp_core_get_directory_page_ids();
     135                $page_names = array_keys( $page_ids );
     136
     137                $this->assertContains( 'register', $page_names );
     138                $this->assertContains( 'activate', $page_names );
     139
     140                remove_filter( 'bp_get_signup_allowed', '__return_true', 999 );
     141        }
     142
     143        public function test_bp_core_get_directory_page_ids_should_not_contain_register_and_activet_pages_when_registration_is_closed() {
     144
     145                // Make sure the pages exist, to verify they're filtered out.
     146                add_filter( 'bp_get_signup_allowed', '__return_true', 999 );
     147                $ac = buddypress()->active_components;
     148                bp_core_add_page_mappings( array_keys( $ac ) );
     149                remove_filter( 'bp_get_signup_allowed', '__return_true', 999 );
     150
     151                // Get page ids
     152                $page_ids = bp_core_get_directory_page_ids();
     153
     154                // Need to delete these pages as previously created.
     155                wp_delete_post( $page_ids['register'], true );
     156                wp_delete_post( $page_ids['activate'], true );
     157
     158                add_filter( 'bp_get_signup_allowed', '__return_false', 999 );
     159                bp_core_add_page_mappings( array_keys( $ac ) );
     160                $page_ids = bp_core_get_directory_page_ids();
     161                remove_filter( 'bp_get_signup_allowed', '__return_false', 999 );
     162
     163                $page_names = array_keys( $page_ids );
     164
     165                $this->assertNotContains( 'register', $page_names );
     166                $this->assertNotContains( 'activate', $page_names );
     167        }
     168
     169        public function test_bp_core_get_directory_pages_register_activate_page_created_signups_allowed() {
     170                add_filter( 'bp_get_signup_allowed', '__return_true', 999 );
     171
     172                $ac = buddypress()->active_components;
     173                bp_core_add_page_mappings( array_keys( $ac ) );
     174                $directory_pages = bp_core_get_directory_pages();
     175
     176                remove_filter( 'bp_get_signup_allowed', '__return_true', 999 );
     177
     178                $this->assertTrue( isset( $directory_pages->register ) );
     179                $this->assertTrue( isset( $directory_pages->activate ) );
     180
     181                $r = get_post( $directory_pages->register->id );
     182                $this->assertTrue( 'publish' == $r->post_status );
     183
     184                $a = get_post( $directory_pages->activate->id );
     185                $this->assertTrue( 'publish' == $a->post_status );
     186        }
     187
     188        public function test_bp_core_get_directory_pages_register_activate_page_notcreated_signups_allowed() {
     189                add_filter( 'bp_get_signup_allowed', '__return_false', 999 );
     190
     191                $ac = buddypress()->active_components;
     192                bp_core_add_page_mappings( array_keys( $ac ) );
     193
     194                remove_filter( 'bp_get_signup_allowed', '__return_false', 999 );
     195
     196                add_filter( 'bp_get_signup_allowed', '__return_true', 999 );
     197
     198                $directory_pages = bp_core_get_directory_pages();
     199
     200                remove_filter( 'bp_get_signup_allowed', '__return_true', 999 );
     201
     202                $this->assertFalse( isset( $directory_pages->register ) );
     203                $this->assertFalse( isset( $directory_pages->activate ) );
     204        }
     205
     206        public function test_bp_core_get_directory_pages_register_activate_page_created_signups_notallowed() {
     207                add_filter( 'bp_get_signup_allowed', '__return_true', 999 );
     208
     209                $ac = buddypress()->active_components;
     210                bp_core_add_page_mappings( array_keys( $ac ) );
     211
     212                remove_filter( 'bp_get_signup_allowed', '__return_true', 999 );
     213
     214                add_filter( 'bp_get_signup_allowed', '__return_false', 999 );
     215
     216                $directory_pages = bp_core_get_directory_pages();
     217
     218                remove_filter( 'bp_get_signup_allowed', '__return_false', 999 );
     219
     220                $this->assertTrue( isset( $directory_pages->register ) );
     221                $this->assertTrue( isset( $directory_pages->activate ) );
     222
     223                $r = get_post( $directory_pages->register->id );
     224                $this->assertTrue( 'publish' == $r->post_status );
     225
     226                $a = get_post( $directory_pages->activate->id );
     227                $this->assertTrue( 'publish' == $a->post_status );
     228        }
     229
     230        public function test_bp_core_get_directory_pages_register_activate_page_notcreated_signups_notallowed() {
     231
     232                add_filter( 'bp_get_signup_allowed', '__return_false', 999 );
     233
     234                $ac = buddypress()->active_components;
     235                bp_core_add_page_mappings( array_keys( $ac ) );
     236                $directory_pages = bp_core_get_directory_pages();
     237
     238                remove_filter( 'bp_get_signup_allowed', '__return_false', 999 );
     239
     240                $this->assertFalse( isset( $directory_pages->register ) );
     241                $this->assertFalse( isset( $directory_pages->activate ) );
     242        }
     243
     244        public function test_bp_core_get_directory_pages_pages_settings_update() {
     245                // Set the cache
     246                $pages = bp_core_get_directory_pages();
     247
     248                // Mess with it but put it back
     249                $v = bp_get_option( 'bp-pages' );
     250                bp_update_option( 'bp-pages', 'foo' );
     251
     252                $this->assertFalse( wp_cache_get( 'directory_pages', 'bp' ) );
     253
     254                bp_update_option( 'bp-pages', $v );
     255        }
     256
     257        public function test_bp_core_get_directory_pages_multisite_delete_post_with_same_bp_page_id() {
     258                if ( ! is_multisite() ) {
     259                        return;
     260                }
     261
     262                $dir_pages = bp_core_get_directory_pages();
     263
     264                // create a blog
     265                $u = $this->factory->user->create();
     266                $b1 = $this->factory->blog->create( array( 'user_id' => $u ) );
     267
     268                // switch to blog and create some dummy posts until we reach a post ID that
     269                // matches our BP activity page ID
     270                switch_to_blog( $b1 );
     271                $p = $this->factory->post->create();
     272                while( $p <= $dir_pages->activity->id ) {
     273                        $p = $this->factory->post->create();
     274                }
     275
     276                // delete the post that matches the BP activity page ID on this sub-site
     277                wp_delete_post( $dir_pages->activity->id, true );
     278
     279                // restore blog
     280                restore_current_blog();
     281
     282                // refetch BP directory pages
     283                $dir_pages = bp_core_get_directory_pages();
     284
     285                // Now verify that our BP activity page was not wiped out
     286                $this->assertNotEmpty( $dir_pages->activity );
     287        }
     288}