Skip to:
Content

BuddyPress.org


Ignore:
Timestamp:
03/10/2015 03:23:36 PM (12 years ago)
Author:
boonebgorges
Message:

bp_core_get_directory_page_ids() should skip bp_is_active() check in save context.

In [9177], a bp_is_active() check was added to bp_core_get_directory_page_ids()
such that the function would not return page mappings for inactive components.
This change caused problems for custom components, as the bp_is_active()
check didn't always pass for components that didn't manually set themselves in
the active_components array. [9553] and [9555] addressed this problem by only
filtering out packaged components. See #6244. But this fix was not truly
general, as it still resulted in the deletion of bp-pages entries related to
third-party deactivated components when saving the page mapping settings.

This changeset introduces a more general fix, by distinguishing between two
different use "contexts" of bp_core_get_directory_page_ids():

  • Read-only - When pulling up page IDs for display or for URI parsing, deactivated components should be ignored.
  • Save - When modifying the bp-pages array stored in the database, we should be working with raw page data, including deactivated components.

The new $status parameter for bp_core_get_directory_page_ids() addresses
this distinction (possible values 'all' and 'active'). We then pass 'all' as
required in BP - namely, when modifying the bp-pages setting. This change
supercedes the fixes from #6244.

Props dtc7240, boonebgorges.
Fixes #6280.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r9509 r9608  
    450450
    451451                $this->assertFalse( wp_cache_get( 'directory_pages', 'bp' ) );
    452         }
    453 
    454         /**
    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 );
    724452        }
    725453
Note: See TracChangeset for help on using the changeset viewer.