Skip to:
Content

BuddyPress.org

Changeset 12317


Ignore:
Timestamp:
12/07/2018 06:41:16 PM (8 years ago)
Author:
boonebgorges
Message:

XProfile: Add caching to group and field queries.

See #7435.

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/bp-xprofile/bp-xprofile-cache.php

    r11818 r12317  
    288288add_action( 'xprofile_field_before_save', 'bp_xprofile_reset_fields_by_name_cache_incrementor' );
    289289
     290/**
     291 * Resets all incremented bp_xprofile_groups caches.
     292 *
     293 * @since 5.0.0
     294 */
     295function bp_xprofile_reset_groups_cache_incrementor() {
     296        bp_core_reset_incrementor( 'bp_xprofile_groups' );
     297}
     298add_action( 'xprofile_group_after_delete', 'bp_xprofile_reset_groups_cache_incrementor' );
     299add_action( 'xprofile_group_after_save', 'bp_xprofile_reset_groups_cache_incrementor' );
     300add_action( 'xprofile_field_after_delete', 'bp_xprofile_reset_groups_cache_incrementor' );
     301add_action( 'xprofile_field_after_save', 'bp_xprofile_reset_groups_cache_incrementor' );
     302
    290303// List actions to clear super cached pages on, if super cache is installed.
    291304add_action( 'xprofile_updated_profile', 'bp_core_clear_cache' );

  • trunk/src/bp-xprofile/classes/class-bp-xprofile-field.php

    r11847 r12317  
    978978                $parent     = $wpdb->query( $sql );
    979979
     980                $retval = false;
     981
    980982                // Update $field_id with new $position and $field_group_id.
    981983                if ( ! empty( $parent ) && ! is_wp_error( $parent ) ) {
    … …  
    985987                        $wpdb->query( $sql );
    986988
    987                         // Invalidate profile field cache.
     989                        // Invalidate profile field and group query cache.
    988990                        wp_cache_delete( $field_id, 'bp_xprofile_fields' );
    989991
    990                         return $parent;
    991                 }
    992 
    993                 return false;
     992                        $retval = $parent;
     993                }
     994
     995                bp_core_reset_incrementor( 'bp_xprofile_groups' );
     996
     997                return $retval;
    994998        }
    995999

  • trunk/src/bp-xprofile/classes/class-bp-xprofile-group.php

    r12210 r12317  
    289289                );
    290290
    291                 // WHERE.
     291                $bp = buddypress();
     292
     293                $group_ids = self::get_group_ids( $r );
     294
     295                // Get all group data.
     296                $groups = self::get_group_data( $group_ids );
     297
     298                // Bail if not also getting fields.
     299                if ( empty( $r['fetch_fields'] ) ) {
     300                        return $groups;
     301                }
     302
     303                // Get the group ids from the groups we found.
     304                $group_ids = wp_list_pluck( $groups, 'id' );
     305
     306                // Store for meta cache priming.
     307                $object_ids['group'] = $group_ids;
     308
     309                // Bail if no groups found.
     310                if ( empty( $group_ids ) ) {
     311                        return $groups;
     312                }
     313
     314                $field_ids = self::get_group_field_ids( $group_ids, $r );
     315
     316                foreach( $groups as $group ) {
     317                        $group->fields = array();
     318                }
     319
     320                // Bail if no fields.
     321                if ( empty( $field_ids ) ) {
     322                        return $groups;
     323                }
     324
     325                $field_ids = array_map( 'intval', $field_ids );
     326
     327                // Prime the field cache.
     328                $uncached_field_ids = bp_get_non_cached_ids( $field_ids, 'bp_xprofile_fields' );
     329                if ( ! empty( $uncached_field_ids ) ) {
     330                        $_uncached_field_ids = implode( ',', array_map( 'intval', $uncached_field_ids ) );
     331                        $uncached_fields = $wpdb->get_results( "SELECT * FROM {$bp->profile->table_name_fields} WHERE id IN ({$_uncached_field_ids})" );
     332                        foreach ( $uncached_fields as $uncached_field ) {
     333                                $fid = intval( $uncached_field->id );
     334                                wp_cache_set( $fid, $uncached_field, 'bp_xprofile_fields' );
     335                        }
     336                }
     337
     338                // Pull field objects from the cache.
     339                $fields = array();
     340                foreach ( $field_ids as $field_id ) {
     341                        $fields[] = xprofile_get_field( $field_id, null, false );
     342                }
     343
     344                // Store field IDs for meta cache priming.
     345                $object_ids['field'] = $field_ids;
     346
     347                // Maybe fetch field data.
     348                if ( ! empty( $r['fetch_field_data'] ) ) {
     349
     350                        // Get field data for user ID.
     351                        if ( ! empty( $field_ids ) && ! empty( $r['user_id'] ) ) {
     352                                $field_data = BP_XProfile_ProfileData::get_data_for_user( $r['user_id'], $field_ids );
     353                        }
     354
     355                        // Remove data-less fields, if necessary.
     356                        if ( ! empty( $r['hide_empty_fields'] ) && ! empty( $field_ids ) && ! empty( $field_data ) ) {
     357
     358                                // Loop through the results and find the fields that have data.
     359                                foreach( (array) $field_data as $data ) {
     360
     361                                        // Empty fields may contain a serialized empty array.
     362                                        $maybe_value = maybe_unserialize( $data->value );
     363
     364                                        // Valid field values of 0 or '0' get caught by empty(), so we have an extra check for these. See #BP5731.
     365                                        if ( ( ! empty( $maybe_value ) || '0' == $maybe_value ) && false !== $key = array_search( $data->field_id, $field_ids ) ) {
     366
     367                                                // Fields that have data get removed from the list.
     368                                                unset( $field_ids[ $key ] );
     369                                        }
     370                                }
     371
     372                                // The remaining members of $field_ids are empty. Remove them.
     373                                foreach( $fields as $field_key => $field ) {
     374                                        if ( in_array( $field->id, $field_ids ) ) {
     375                                                unset( $fields[ $field_key ] );
     376                                        }
     377                                }
     378
     379                                // Reset indexes.
     380                                $fields = array_values( $fields );
     381                        }
     382
     383                        // Field data was found.
     384                        if ( ! empty( $fields ) && ! empty( $field_data ) && ! is_wp_error( $field_data ) ) {
     385
     386                                // Loop through fields.
     387                                foreach( (array) $fields as $field_key => $field ) {
     388
     389                                        // Loop through the data in each field.
     390                                        foreach( (array) $field_data as $data ) {
     391
     392                                                // Assign correct data value to the field.
     393                                                if ( $field->id == $data->field_id ) {
     394                                                        $fields[ $field_key ]->data        = new stdClass;
     395                                                        $fields[ $field_key ]->data->value = $data->value;
     396                                                        $fields[ $field_key ]->data->id    = $data->id;
     397                                                }
     398
     399                                                // Store for meta cache priming.
     400                                                $object_ids['data'][] = $data->id;
     401                                        }
     402                                }
     403                        }
     404                }
     405
     406                // Prime the meta cache, if necessary.
     407                if ( ! empty( $r['update_meta_cache'] ) ) {
     408                        bp_xprofile_update_meta_cache( $object_ids );
     409                }
     410
     411                // Maybe fetch visibility levels.
     412                if ( ! empty( $r['fetch_visibility_level'] ) ) {
     413                        $fields = self::fetch_visibility_level( $r['user_id'], $fields );
     414                }
     415
     416                // Merge the field array back in with the group array.
     417                foreach( (array) $groups as $group ) {
     418                        // Indexes may have been shifted after previous deletions, so we get a
     419                        // fresh one each time through the loop.
     420                        $index = array_search( $group, $groups );
     421
     422                        foreach( (array) $fields as $field ) {
     423                                if ( $group->id === $field->group_id ) {
     424                                        $groups[ $index ]->fields[] = $field;
     425                                }
     426                        }
     427
     428                        // When we unset fields above, we may have created empty groups.
     429                        // Remove them, if necessary.
     430                        if ( empty( $group->fields ) && ! empty( $r['hide_empty_groups'] ) ) {
     431                                unset( $groups[ $index ] );
     432                        }
     433
     434                        // Reset indexes.
     435                        $groups = array_values( $groups );
     436                }
     437
     438                return $groups;
     439        }
     440
     441        /**
     442         * Gets group IDs, based on passed parameters.
     443         *
     444         * @since 5.0.0
     445         *
     446         * @param array $args {
     447         *    Array of optional arguments:
     448         *    @type int   $profile_group_id  Limit results to a single profile group. Default false.
     449         *    @type array $exclude_groups    Comma-separated list or array of group IDs to exclude. Default false.
     450         *    @type bool  $hide_empty_groups True to hide groups that don't have any fields. Default: false.
     451         * }
     452         * @return array
     453         */
     454        public static function get_group_ids( $args = array() ) {
     455                global $wpdb;
     456
     457                $r = array_merge(
     458                        array(
     459                                'profile_group_id'  => false,
     460                                'exclude_groups'    => false,
     461                                'hide_empty_groups' => false,
     462                        ),
     463                        $args
     464                );
     465
     466                $bp = buddypress();
     467
    292468                if ( ! empty( $r['profile_group_id'] ) ) {
    293469                        $where_sql = $wpdb->prepare( 'WHERE g.id = %d', $r['profile_group_id'] );
    … …  
    299475                }
    300476
    301                 $bp = buddypress();
    302 
    303477                // Include or exclude empty groups.
    304478                if ( ! empty( $r['hide_empty_groups'] ) ) {
    305                         $group_ids = $wpdb->get_col( "SELECT DISTINCT g.id FROM {$bp->profile->table_name_groups} g INNER JOIN {$bp->profile->table_name_fields} f ON g.id = f.group_id {$where_sql} ORDER BY g.group_order ASC" );
     479                        $group_ids_sql = "SELECT DISTINCT g.id FROM {$bp->profile->table_name_groups} g INNER JOIN {$bp->profile->table_name_fields} f ON g.id = f.group_id {$where_sql} ORDER BY g.group_order ASC";
    306480                } else {
    307                         $group_ids = $wpdb->get_col( "SELECT DISTINCT g.id FROM {$bp->profile->table_name_groups} g {$where_sql} ORDER BY g.group_order ASC" );
    308                 }
    309 
    310                 // Get all group data.
    311                 $groups = self::get_group_data( $group_ids );
    312 
    313                 // Bail if not also getting fields.
    314                 if ( empty( $r['fetch_fields'] ) ) {
    315                         return $groups;
    316                 }
    317 
    318                 // Get the group ids from the groups we found.
    319                 $group_ids = wp_list_pluck( $groups, 'id' );
    320 
    321                 // Store for meta cache priming.
    322                 $object_ids['group'] = $group_ids;
    323 
    324                 // Bail if no groups found.
     481                        $group_ids_sql = "SELECT DISTINCT g.id FROM {$bp->profile->table_name_groups} g {$where_sql} ORDER BY g.group_order ASC";
     482                }
     483
     484                $cached = bp_core_get_incremented_cache( $group_ids_sql, 'bp_xprofile_groups' );
     485                if ( false === $cached ) {
     486                        $group_ids = $wpdb->get_col( $group_ids_sql );
     487                        bp_core_set_incremented_cache( $group_ids_sql, 'bp_xprofile_groups', $group_ids );
     488                } else {
     489                        $group_ids = $cached;
     490                }
     491
     492                return array_map( 'intval', $group_ids );
     493        }
     494
     495        /**
     496         * Gets group field IDs, based on passed parameters.
     497         *
     498         * @since 5.0.0
     499         *
     500         * @param array $group_ids Array of group IDs.
     501         * @param array $args {
     502         *    Array of optional arguments:
     503         *      @type array        $exclude_fields    Comma-separated list or array of field IDs to exclude.
     504         *                                            Default empty.
     505         *      @type int          $user_id           Limit results to fields associated with a given user's
     506         *                                            member type. Default empty.
     507         *      @type array|string $member_type       Limit fields by those restricted to a given member type, or array of
     508         *                                            member types. If `$user_id` is provided, the value of `$member_type`
     509         *                                            is honored.
     510         * }
     511         * @return array
     512         */
     513        public static function get_group_field_ids( $group_ids, $args = array() ) {
     514                global $wpdb;
     515
     516                $r = array_merge(
     517                        array(
     518                                'exclude_fields' => false,
     519                                'user_id' => false,
     520                                'member_type' => false,
     521                        ),
     522                        $args
     523                );
     524
     525                $bp = buddypress();
     526
     527                // Setup IN query from group IDs.
    325528                if ( empty( $group_ids ) ) {
    326                         return $groups;
    327                 }
    328 
    329                 // Setup IN query from group IDs.
    330                 $group_ids_in = implode( ',', (array) $group_ids );
     529                        $group_ids = array( 0 );
     530                }
     531                $group_ids_in = implode( ',', array_map( 'intval', $group_ids ) );
    331532
    332533                // Support arrays and comma-separated strings.
    … …  
    371572                }
    372573
    373                 // Fetch the fields.
    374                 $field_ids = $wpdb->get_col( "SELECT id FROM {$bp->profile->table_name_fields} WHERE group_id IN ( {$group_ids_in} ) AND parent_id = 0 {$exclude_fields_sql} {$in_sql} ORDER BY field_order" );
    375 
    376                 foreach( $groups as $group ) {
    377                         $group->fields = array();
    378                 }
    379 
    380                 // Bail if no fields.
    381                 if ( empty( $field_ids ) ) {
    382                         return $groups;
    383                 }
    384 
    385                 $field_ids = array_map( 'intval', $field_ids );
    386 
    387                 // Prime the field cache.
    388                 $uncached_field_ids = bp_get_non_cached_ids( $field_ids, 'bp_xprofile_fields' );
    389                 if ( ! empty( $uncached_field_ids ) ) {
    390                         $_uncached_field_ids = implode( ',', array_map( 'intval', $uncached_field_ids ) );
    391                         $uncached_fields = $wpdb->get_results( "SELECT * FROM {$bp->profile->table_name_fields} WHERE id IN ({$_uncached_field_ids})" );
    392                         foreach ( $uncached_fields as $uncached_field ) {
    393                                 $fid = intval( $uncached_field->id );
    394                                 wp_cache_set( $fid, $uncached_field, 'bp_xprofile_fields' );
    395                         }
    396                 }
    397 
    398                 // Pull field objects from the cache.
    399                 $fields = array();
    400                 foreach ( $field_ids as $field_id ) {
    401                         $fields[] = xprofile_get_field( $field_id, null, false );
    402                 }
    403 
    404                 // Store field IDs for meta cache priming.
    405                 $object_ids['field'] = $field_ids;
    406 
    407                 // Maybe fetch field data.
    408                 if ( ! empty( $r['fetch_field_data'] ) ) {
    409 
    410                         // Get field data for user ID.
    411                         if ( ! empty( $field_ids ) && ! empty( $r['user_id'] ) ) {
    412                                 $field_data = BP_XProfile_ProfileData::get_data_for_user( $r['user_id'], $field_ids );
    413                         }
    414 
    415                         // Remove data-less fields, if necessary.
    416                         if ( ! empty( $r['hide_empty_fields'] ) && ! empty( $field_ids ) && ! empty( $field_data ) ) {
    417 
    418                                 // Loop through the results and find the fields that have data.
    419                                 foreach( (array) $field_data as $data ) {
    420 
    421                                         // Empty fields may contain a serialized empty array.
    422                                         $maybe_value = maybe_unserialize( $data->value );
    423 
    424                                         // Valid field values of 0 or '0' get caught by empty(), so we have an extra check for these. See #BP5731.
    425                                         if ( ( ! empty( $maybe_value ) || '0' == $maybe_value ) && false !== $key = array_search( $data->field_id, $field_ids ) ) {
    426 
    427                                                 // Fields that have data get removed from the list.
    428                                                 unset( $field_ids[ $key ] );
    429                                         }
    430                                 }
    431 
    432                                 // The remaining members of $field_ids are empty. Remove them.
    433                                 foreach( $fields as $field_key => $field ) {
    434                                         if ( in_array( $field->id, $field_ids ) ) {
    435                                                 unset( $fields[ $field_key ] );
    436                                         }
    437                                 }
    438 
    439                                 // Reset indexes.
    440                                 $fields = array_values( $fields );
    441                         }
    442 
    443                         // Field data was found.
    444                         if ( ! empty( $fields ) && ! empty( $field_data ) && ! is_wp_error( $field_data ) ) {
    445 
    446                                 // Loop through fields.
    447                                 foreach( (array) $fields as $field_key => $field ) {
    448 
    449                                         // Loop through the data in each field.
    450                                         foreach( (array) $field_data as $data ) {
    451 
    452                                                 // Assign correct data value to the field.
    453                                                 if ( $field->id == $data->field_id ) {
    454                                                         $fields[ $field_key ]->data        = new stdClass;
    455                                                         $fields[ $field_key ]->data->value = $data->value;
    456                                                         $fields[ $field_key ]->data->id    = $data->id;
    457                                                 }
    458 
    459                                                 // Store for meta cache priming.
    460                                                 $object_ids['data'][] = $data->id;
    461                                         }
    462                                 }
    463                         }
    464                 }
    465 
    466                 // Prime the meta cache, if necessary.
    467                 if ( ! empty( $r['update_meta_cache'] ) ) {
    468                         bp_xprofile_update_meta_cache( $object_ids );
    469                 }
    470 
    471                 // Maybe fetch visibility levels.
    472                 if ( ! empty( $r['fetch_visibility_level'] ) ) {
    473                         $fields = self::fetch_visibility_level( $r['user_id'], $fields );
    474                 }
    475 
    476                 // Merge the field array back in with the group array.
    477                 foreach( (array) $groups as $group ) {
    478                         // Indexes may have been shifted after previous deletions, so we get a
    479                         // fresh one each time through the loop.
    480                         $index = array_search( $group, $groups );
    481 
    482                         foreach( (array) $fields as $field ) {
    483                                 if ( $group->id === $field->group_id ) {
    484                                         $groups[ $index ]->fields[] = $field;
    485                                 }
    486                         }
    487 
    488                         // When we unset fields above, we may have created empty groups.
    489                         // Remove them, if necessary.
    490                         if ( empty( $group->fields ) && ! empty( $r['hide_empty_groups'] ) ) {
    491                                 unset( $groups[ $index ] );
    492                         }
    493 
    494                         // Reset indexes.
    495                         $groups = array_values( $groups );
    496                 }
    497 
    498                 return $groups;
     574                $field_ids_sql = "SELECT id FROM {$bp->profile->table_name_fields} WHERE group_id IN ( {$group_ids_in} ) AND parent_id = 0 {$exclude_fields_sql} {$in_sql} ORDER BY field_order";
     575
     576                $cached = bp_core_get_incremented_cache( $field_ids_sql, 'bp_xprofile_groups' );
     577                if ( false === $cached ) {
     578                        $field_ids = $wpdb->get_col( $field_ids_sql );
     579                        bp_core_set_incremented_cache( $field_ids_sql, 'bp_xprofile_groups', $field_ids );
     580                } else {
     581                        $field_ids = $cached;
     582                }
     583
     584                return array_map( 'intval', $field_ids );
    499585        }
    500586
    … …  
    614700                }
    615701
    616                 // Purge profile field group cache.
     702                // Purge profile field group and group query caches.
    617703                wp_cache_delete( 'all', 'bp_xprofile_groups' );
     704                bp_core_reset_incrementor( 'bp_xprofile_groups' );
    618705
    619706                $bp = buddypress();

  • trunk/tests/phpunit/testcases/xprofile/class-bp-xprofile-group.php

    r12210 r12317  
    442442                $this->assertSame( "Test ' Name", $e1->name );
    443443        }
     444
     445        /**
     446         * @group BP7435
     447         * @group cache
     448         */
     449        public function test_group_ids_query_should_be_cached() {
     450                global $wpdb;
     451
     452                $group_ids   = array( 1 ); // Default group.
     453                $group_ids[] = self::factory()->xprofile_group->create();
     454                $group_ids[] = self::factory()->xprofile_group->create();
     455                $group_ids[] = self::factory()->xprofile_group->create();
     456
     457                $params_1 = array(
     458                        'exclude_groups' => false,
     459                );
     460
     461                $params_2 = array(
     462                        'exclude_groups' => array( 0 ),
     463                );
     464
     465                // Prime cache.
     466                $found_1 = BP_XProfile_Group::get_group_ids( $params_1 );
     467                $this->assertEqualSets( $group_ids, $found_1 );
     468
     469                $num_queries = $wpdb->num_queries;
     470
     471                $found_1 = BP_XProfile_Group::get_group_ids( $params_1 );
     472                $this->assertEqualSets( $group_ids, $found_1 );
     473                $this->assertSame( $num_queries, $wpdb->num_queries );
     474
     475                // Different parameters should trigger a cache miss.
     476                $found_2 = BP_XProfile_Group::get_group_ids( $params_2 );
     477                $this->assertEqualSets( $group_ids, $found_2 );
     478                $this->assertNotSame( $num_queries, $wpdb->num_queries );
     479        }
     480
     481        /**
     482         * @group BP7435
     483         * @group cache
     484         */
     485        public function test_group_ids_query_cache_should_be_busted_on_group_delete() {
     486                $group_ids    = array( 1 ); // Default group.
     487                $group_ids[1] = self::factory()->xprofile_group->create();
     488                $group_ids[2] = self::factory()->xprofile_group->create();
     489                $group_ids[3] = self::factory()->xprofile_group->create();
     490
     491                // Prime cache.
     492                $found = BP_XProfile_Group::get_group_ids();
     493                $this->assertContains( $group_ids[1], $found );
     494
     495                $g1 = new BP_XProfile_Group( $group_ids[1] );
     496                $g1->delete();
     497
     498                $found = BP_XProfile_Group::get_group_ids();
     499                $this->assertNotContains( $group_ids[1], $found );
     500        }
     501
     502        /**
     503         * @group BP7435
     504         * @group cache
     505         */
     506        public function test_group_ids_query_cache_should_be_busted_on_group_save() {
     507                global $wpdb;
     508
     509                $group_ids    = array( 1 ); // Default group.
     510                $group_ids[1] = self::factory()->xprofile_group->create();
     511                $group_ids[2] = self::factory()->xprofile_group->create();
     512                $group_ids[3] = self::factory()->xprofile_group->create();
     513
     514                // Prime cache.
     515                $found = BP_XProfile_Group::get_group_ids();
     516                $this->assertContains( $group_ids[1], $found );
     517
     518                $g1 = new BP_XProfile_Group( $group_ids[1] );
     519                $g1->save();
     520
     521                $num_queries = $wpdb->num_queries;
     522
     523                $found = BP_XProfile_Group::get_group_ids();
     524                $this->assertNotSame( $num_queries, $wpdb->num_queries );
     525        }
     526
     527        /**
     528         * @group BP7435
     529         * @group cache
     530         */
     531        public function test_group_ids_query_cache_should_be_busted_on_field_save() {
     532                global $wpdb;
     533
     534                $group_ids    = array( 1 ); // Default group.
     535                $group_ids[1] = self::factory()->xprofile_group->create();
     536                $group_ids[2] = self::factory()->xprofile_group->create();
     537                $group_ids[3] = self::factory()->xprofile_group->create();
     538
     539                $f = self::factory()->xprofile_field->create( array(
     540                        'field_group_id' => $group_ids[1],
     541                ) );
     542                $field = new BP_XProfile_Field( $f );
     543
     544                // Prime cache.
     545                $found = BP_XProfile_Group::get_group_ids();
     546                $this->assertContains( $group_ids[1], $found );
     547
     548                $field->save();
     549
     550                $num_queries = $wpdb->num_queries;
     551
     552                $found = BP_XProfile_Group::get_group_ids();
     553                $this->assertNotSame( $num_queries, $wpdb->num_queries );
     554        }
     555
     556        /**
     557         * @group BP7435
     558         * @group cache
     559         */
     560        public function test_group_ids_query_cache_should_be_busted_on_field_delete() {
     561                $group_ids    = array( 1 ); // Default group.
     562                $group_ids[1] = self::factory()->xprofile_group->create();
     563                $group_ids[2] = self::factory()->xprofile_group->create();
     564                $group_ids[3] = self::factory()->xprofile_group->create();
     565
     566                $f = self::factory()->xprofile_field->create( array(
     567                        'field_group_id' => $group_ids[1],
     568                ) );
     569                $field = new BP_XProfile_Field( $f );
     570
     571                $args = array(
     572                        'hide_empty_groups' => true,
     573                );
     574
     575                // Prime cache.
     576                $found = BP_XProfile_Group::get_group_ids( $args );
     577                $this->assertContains( $group_ids[1], $found );
     578
     579                $field->delete();
     580
     581                $found = BP_XProfile_Group::get_group_ids( $args );
     582                $this->assertNotContains( $group_ids[1], $found );
     583        }
     584
     585        /**
     586         * @group BP7435
     587         * @group cache
     588         */
     589        public function test_group_field_ids_query_cache() {
     590                global $wpdb;
     591
     592                $group_id = self::factory()->xprofile_group->create();
     593
     594                $f = self::factory()->xprofile_field->create( array(
     595                        'field_group_id' => $group_id,
     596                ) );
     597                $field = new BP_XProfile_Field( $f );
     598
     599                // Prime cache.
     600                $found = BP_XProfile_Group::get_group_field_ids( array( $group_id ) );
     601                $this->assertContains( $f, $found );
     602
     603                $num_queries = $wpdb->num_queries;
     604
     605                $found = BP_XProfile_Group::get_group_field_ids( array( $group_id ) );
     606                $this->assertContains( $f, $found );
     607                $this->assertSame( $num_queries, $wpdb->num_queries );
     608        }
     609
     610        /**
     611         * @group BP7435
     612         * @group cache
     613         */
     614        public function test_group_field_ids_query_cache_should_be_busted_on_field_save() {
     615                global $wpdb;
     616
     617                $group_id = self::factory()->xprofile_group->create();
     618
     619                $f = self::factory()->xprofile_field->create( array(
     620                        'field_group_id' => $group_id,
     621                ) );
     622                $field = new BP_XProfile_Field( $f );
     623
     624                // Prime cache.
     625                $found = BP_XProfile_Group::get_group_field_ids( array( $group_id ) );
     626                $this->assertContains( $f, $found );
     627
     628                $field->save();
     629                $num_queries = $wpdb->num_queries;
     630
     631                $found = BP_XProfile_Group::get_group_field_ids( array( $group_id ) );
     632                $this->assertContains( $f, $found );
     633                $this->assertNotSame( $num_queries, $wpdb->num_queries );
     634        }
     635
     636        /**
     637         * @group BP7435
     638         * @group cache
     639         */
     640        public function test_group_field_ids_query_cache_should_be_busted_on_field_delete() {
     641                $group_id = self::factory()->xprofile_group->create();
     642
     643                $f = self::factory()->xprofile_field->create( array(
     644                        'field_group_id' => $group_id,
     645                ) );
     646                $field = new BP_XProfile_Field( $f );
     647
     648                // Prime cache.
     649                $found = BP_XProfile_Group::get_group_field_ids( array( $group_id ) );
     650                $this->assertContains( $f, $found );
     651
     652                $field->delete();
     653
     654                $found = BP_XProfile_Group::get_group_field_ids( array( $group_id ) );
     655                $this->assertNotContains( $f, $found );
     656        }
    444657}
Note: See TracChangeset for help on using the changeset viewer.