WordPress.org
Get WordPress

Make WordPress Core

Changeset 55745


Ignore:
Timestamp:
05/11/2023 10:05:51 AM (3 years ago)
Author:
spacedmonkey
Message:

Tests: Use the function get_num_queries across all unit tests.

Replace use of $wpdb->num_queries with a function call to get_num_queries. This improves readability and consistency between tests.

Props SergeyBiryukov, peterwilsoncc, spacedmonkey.
See #57841.

Location:
trunk
Files:
32 edited

Legend:

Unmodified
Added
Removed

  • trunk/package-lock.json

    r55737 r55745  
    1195511955                        "version": "1.1.0",
    1195611956                        "resolved": "https://registry.npmjs.org/from2-string/-/from2-string-1.1.0.tgz",
    11957                         "integrity": "sha512-m8vCh+KnXXXBtfF2VUbiYlQ+nczLcntB0BrtNgpmLkHylhObe9WF1b2LZjBBzrZzA6P4mkEla6ZYQoOUTG8cYA==",
     11957                        "integrity": "sha1-GCgrJ9CKJnyzAwzSuLSw8hKvdSo=",
    1195811958                        "requires": {
    1195911959                                "from2": "^2.0.3"
    … …  
    2111321113                        "version": "1.1.6",
    2111421114                        "resolved": "https://registry.npmjs.org/promise-polyfill/-/promise-polyfill-1.1.6.tgz",
    21115                         "integrity": "sha512-7rrONfyLkDEc7OJ5QBkqa4KI4EBhCd340xRuIUPGCfu13znS+vx+VDdrT9ODAJHlXm7w4lbxN3DRjyv58EuzDg=="
     21115                        "integrity": "sha1-zQTv9G9clcOn0EVZHXm14+AfEtc="
    2111621116                },
    2111721117                "prompts": {
    … …  
    2325223252                        "version": "1.0.0",
    2325323253                        "resolved": "https://registry.npmjs.org/stream-from-promise/-/stream-from-promise-1.0.0.tgz",
    23254                         "integrity": "sha512-j84KLkudt+gr8KJ21RB02btPLx61uGbrLnewsWz6QKmsz8/c4ZFqXw6mJh5+G4oRN7DgDxdbjPxnpySpg1mUig=="
     23254                        "integrity": "sha1-djaH9913fkyJT2QIMz/Gs/yKYbs="
    2325523255                },
    2325623256                "stream-to-string": {
    … …  
    2452024520                        "version": "2.0.2",
    2452124521                        "resolved": "https://registry.npmjs.org/toposort/-/toposort-2.0.2.tgz",
    24522                         "integrity": "sha512-0a5EOkAUp8D4moMi2W8ZF8jcga7BgZd91O/yabJCFY8az+XSzeGyTKs0Aoo897iV1Nj6guFq8orWDS96z91oGg=="
     24522                        "integrity": "sha1-riF2gXXRVZ1IvvNUILL0li8JwzA="
    2452324523                },
    2452424524                "totalist": {

  • trunk/tests/phpunit/tests/bookmark/getBookmarks.php

    r51454 r55745  
    66class Tests_Bookmark_GetBookmarks extends WP_UnitTestCase {
    77        public function test_should_hit_cache() {
    8                 global $wpdb;
    9 
    108                $bookmarks = self::factory()->bookmark->create_many( 2 );
    119
    … …  
    1614                );
    1715
    18                 $num_queries = $wpdb->num_queries;
     16                $num_queries = get_num_queries();
    1917
    2018                $found2 = get_bookmarks(
    … …  
    2523
    2624                $this->assertSameSets( $found1, $found2 );
    27                 $this->assertSame( $num_queries, $wpdb->num_queries );
     25                $this->assertSame( $num_queries, get_num_queries() );
    2826        }
    2927
    3028        public function test_adding_bookmark_should_bust_get_bookmarks_cache() {
    31                 global $wpdb;
    32 
    3329                $bookmarks = self::factory()->bookmark->create_many( 2 );
    3430
    … …  
    4036                );
    4137
    42                 $num_queries = $wpdb->num_queries;
     38                $num_queries = get_num_queries();
    4339
    4440                $bookmarks[] = wp_insert_link(
    … …  
    5652
    5753                $this->assertEqualSets( $bookmarks, wp_list_pluck( $found2, 'link_id' ) );
    58                 $this->assertGreaterThan( $num_queries, $wpdb->num_queries );
     54                $this->assertGreaterThan( $num_queries, get_num_queries() );
    5955        }
    6056
    … …  
    6359         */
    6460        public function test_orderby_rand_should_not_be_cached() {
    65                 global $wpdb;
    66 
    6761                $bookmarks = self::factory()->bookmark->create_many( 2 );
    6862
    … …  
    7367                );
    7468
    75                 $num_queries = $wpdb->num_queries;
     69                $num_queries = get_num_queries();
    7670
    7771                $found2 = get_bookmarks(
    … …  
    8377                // Equal sets != same order.
    8478                $this->assertEqualSets( $found1, $found2 );
    85                 $this->assertGreaterThan( $num_queries, $wpdb->num_queries );
     79                $this->assertGreaterThan( $num_queries, get_num_queries() );
    8680        }
    8781

  • trunk/tests/phpunit/tests/comment/getPageOfComment.php

    r53863 r55745  
    101101         */
    102102        public function test_subsequent_calls_should_hit_cache() {
    103                 global $wpdb;
    104 
    105103                $p = self::factory()->post->create();
    106104                $c = self::factory()->comment->create( array( 'comment_post_ID' => $p ) );
    … …  
    109107                $page_1 = get_page_of_comment( $c, array( 'per_page' => 3 ) );
    110108
    111                 $num_queries = $wpdb->num_queries;
     109                $num_queries = get_num_queries();
    112110                $page_2      = get_page_of_comment( $c, array( 'per_page' => 3 ) );
    113111
    114112                $this->assertSame( $page_1, $page_2 );
    115                 $this->assertSame( $num_queries, $wpdb->num_queries );
     113                $this->assertSame( $num_queries, get_num_queries() );
    116114        }
    117115
    … …  
    120118         */
    121119        public function test_cache_hits_should_be_sensitive_to_comment_type() {
    122                 global $wpdb;
    123 
    124120                $p       = self::factory()->post->create();
    125121                $comment = self::factory()->comment->create(
    … …  
    152148                $this->assertSame( 2, $page_trackbacks );
    153149
    154                 $num_queries   = $wpdb->num_queries;
     150                $num_queries   = get_num_queries();
    155151                $page_comments = get_page_of_comment(
    156152                        $comment,
    … …  
    162158                $this->assertSame( 1, $page_comments );
    163159
    164                 $this->assertNotEquals( $num_queries, $wpdb->num_queries );
     160                $this->assertNotEquals( $num_queries, get_num_queries() );
    165161        }
    166162

  • trunk/tests/phpunit/tests/comment/metaCache.php

    r54704 r55745  
    1313         */
    1414        public function test_update_comment_meta_cache_should_default_to_true() {
    15                 global $wpdb;
    16 
    1715                $p           = self::factory()->post->create( array( 'post_status' => 'publish' ) );
    1816                $comment_ids = self::factory()->comment->create_post_comments( $p, 3 );
    … …  
    3129                );
    3230
    33                 $num_queries = $wpdb->num_queries;
     31                $num_queries = get_num_queries();
    3432                foreach ( $comment_ids as $cid ) {
    3533                        get_comment_meta( $cid, 'foo', 'bar' );
    3634                }
    3735
    38                 $this->assertSame( $num_queries, $wpdb->num_queries );
     36                $this->assertSame( $num_queries, get_num_queries() );
    3937        }
    4038
    … …  
    4543         */
    4644        public function test_update_comment_meta_cache_true() {
    47                 global $wpdb;
    48 
    4945                $p           = self::factory()->post->create( array( 'post_status' => 'publish' ) );
    5046                $comment_ids = self::factory()->comment->create_post_comments( $p, 3 );
    … …  
    6460                );
    6561
    66                 $num_queries = $wpdb->num_queries;
     62                $num_queries = get_num_queries();
    6763                foreach ( $comment_ids as $cid ) {
    6864                        get_comment_meta( $cid, 'foo', 'bar' );
    6965                }
    7066
    71                 $this->assertSame( $num_queries, $wpdb->num_queries );
     67                $this->assertSame( $num_queries, get_num_queries() );
    7268        }
    7369
    … …  
    7874         */
    7975        public function test_update_comment_meta_cache_false() {
    80                 global $wpdb;
    81 
    8276                $p           = self::factory()->post->create( array( 'post_status' => 'publish' ) );
    8377                $comment_ids = self::factory()->comment->create_post_comments( $p, 3 );
    … …  
    9488                );
    9589
    96                 $num_queries = $wpdb->num_queries;
     90                $num_queries = get_num_queries();
    9791                foreach ( $comment_ids as $cid ) {
    9892                        get_comment_meta( $cid, 'foo', 'bar' );
    9993                }
    10094
    101                 $this->assertSame( $num_queries + 3, $wpdb->num_queries );
     95                $this->assertSame( $num_queries + 3, get_num_queries() );
    10296        }
    10397
    … …  
    108102         */
    109103        public function test_comment_meta_should_be_lazy_loaded_for_all_comments_in_comments_template() {
    110                 global $wpdb;
    111 
    112104                $p           = self::factory()->post->create( array( 'post_status' => 'publish' ) );
    113105                $comment_ids = self::factory()->comment->create_post_comments( $p, 3 );
    … …  
    127119
    128120                                // First request will hit the database.
    129                                 $num_queries = $wpdb->num_queries;
     121                                $num_queries = get_num_queries();
    130122                                get_comment_meta( $comment_ids[0], 'sauce' );
    131                                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     123                                $this->assertSame( $num_queries + 1, get_num_queries() );
    132124
    133125                                // Second and third requests should be in cache.
    134126                                get_comment_meta( $comment_ids[1], 'sauce' );
    135127                                get_comment_meta( $comment_ids[2], 'sauce' );
    136                                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     128                                $this->assertSame( $num_queries + 1, get_num_queries() );
    137129                        }
    138130                }
    … …  
    145137         */
    146138        public function test_comment_meta_should_be_lazy_loaded_in_comment_feed_queries() {
    147                 global $wpdb;
    148 
    149139                $posts = self::factory()->post->create_many( 2, array( 'post_status' => 'publish' ) );
    150140
    … …  
    174164
    175165                // First comment will cause the cache to be primed.
    176                 $num_queries = $wpdb->num_queries;
     166                $num_queries = get_num_queries();
    177167                $this->assertSame( 'bar', get_comment_meta( $comments[0], 'foo', 'bar' ) );
    178168                $num_queries++;
    179                 $this->assertSame( $num_queries, $wpdb->num_queries );
     169                $this->assertSame( $num_queries, get_num_queries() );
    180170
    181171                // Second comment from the results should not cause more queries.
    182172                $this->assertSame( 'bar', get_comment_meta( $comments[1], 'foo', 'bar' ) );
    183                 $this->assertSame( $num_queries, $wpdb->num_queries );
     173                $this->assertSame( $num_queries, get_num_queries() );
    184174
    185175                // A comment from outside the results will not be primed.
    186176                $this->assertSame( 'bar', get_comment_meta( $comments[4], 'foo', 'bar' ) );
    187177                $num_queries++;
    188                 $this->assertSame( $num_queries, $wpdb->num_queries );
     178                $this->assertSame( $num_queries, get_num_queries() );
    189179        }
    190180
    … …  
    195185         */
    196186        public function test_comment_meta_should_be_lazy_loaded_in_single_post_comment_feed_queries() {
    197                 global $wpdb;
    198 
    199187                $posts = self::factory()->post->create_many( 2, array( 'post_status' => 'publish' ) );
    200188
    … …  
    225213
    226214                // First comment will cause the cache to be primed.
    227                 $num_queries = $wpdb->num_queries;
     215                $num_queries = get_num_queries();
    228216                $this->assertSame( 'bar', get_comment_meta( $comments[0], 'foo', 'bar' ) );
    229217                $num_queries++;
    230                 $this->assertSame( $num_queries, $wpdb->num_queries );
     218                $this->assertSame( $num_queries, get_num_queries() );
    231219
    232220                // Second comment from the results should not cause more queries.
    233221                $this->assertSame( 'bar', get_comment_meta( $comments[1], 'foo', 'bar' ) );
    234                 $this->assertSame( $num_queries, $wpdb->num_queries );
     222                $this->assertSame( $num_queries, get_num_queries() );
    235223
    236224                // A comment from outside the results will not be primed.
    237225                $this->assertSame( 'bar', get_comment_meta( $comments[4], 'foo', 'bar' ) );
    238226                $num_queries++;
    239                 $this->assertSame( $num_queries, $wpdb->num_queries );
     227                $this->assertSame( $num_queries, get_num_queries() );
    240228        }
    241229

  • trunk/tests/phpunit/tests/comment/query.php

    r54704 r55745  
    35893589         */
    35903590        public function test_comment_cache_key_should_ignore_custom_params() {
    3591                 global $wpdb;
    3592 
    35933591                $p = self::factory()->post->create();
    35943592                $c = self::factory()->comment->create( array( 'comment_post_ID' => $p ) );
    … …  
    36023600                );
    36033601
    3604                 $num_queries = $wpdb->num_queries;
     3602                $num_queries = get_num_queries();
    36053603
    36063604                $q2 = new WP_Comment_Query();
    … …  
    36133611                );
    36143612
    3615                 $this->assertSame( $num_queries, $wpdb->num_queries );
     3613                $this->assertSame( $num_queries, get_num_queries() );
    36163614        }
    36173615
    … …  
    36303628                );
    36313629
    3632                 $num_queries = $wpdb->num_queries;
     3630                $num_queries = get_num_queries();
    36333631
    36343632                $q2 = new WP_Comment_Query(
    … …  
    36383636                );
    36393637
    3640                 $this->assertNotEquals( $num_queries, $wpdb->num_queries );
     3638                $this->assertNotEquals( $num_queries, get_num_queries() );
    36413639        }
    36423640
    … …  
    36553653                );
    36563654
    3657                 $num_queries = $wpdb->num_queries;
     3655                $num_queries = get_num_queries();
    36583656
    36593657                $q2 = new WP_Comment_Query(
    … …  
    36633661                );
    36643662
    3665                 $this->assertNotEquals( $num_queries, $wpdb->num_queries );
     3663                $this->assertNotEquals( $num_queries, get_num_queries() );
    36663664        }
    36673665
    … …  
    44284426                $q1_ids = wp_list_pluck( $q1->comments, 'comment_ID' );
    44294427
    4430                 $num_queries = $wpdb->num_queries;
     4428                $num_queries = get_num_queries();
    44314429                $q2          = new WP_Comment_Query(
    44324430                        array(
    … …  
    44384436
    44394437                $this->assertSameSets( $q1_ids, $q2_ids );
    4440                 $this->assertSame( $num_queries, $wpdb->num_queries );
     4438                $this->assertSame( $num_queries, get_num_queries() );
    44414439        }
    44424440
    … …  
    45914589                );
    45924590
    4593                 $num_queries = $wpdb->num_queries;
     4591                $num_queries = get_num_queries();
    45944592                $this->assertTrue( isset( $q->comments[0]->post_name ) );
    4595                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     4593                $this->assertSame( $num_queries + 1, get_num_queries() );
    45964594        }
    45974595
    … …  
    46144612                );
    46154613
    4616                 $num_queries = $wpdb->num_queries;
     4614                $num_queries = get_num_queries();
    46174615                $this->assertTrue( isset( $q->comments[0]->post_name ) );
    4618                 $this->assertSame( $num_queries, $wpdb->num_queries );
     4616                $this->assertSame( $num_queries, get_num_queries() );
    46194617        }
    46204618
    … …  
    46304628                clean_comment_cache( $comments );
    46314629
    4632                 $num_queries = $wpdb->num_queries;
     4630                $num_queries = get_num_queries();
    46334631                $q           = new WP_Comment_Query(
    46344632                        array(
    … …  
    46464644                $this->assertEqualSets( $comments, $found );
    46474645
    4648                 $this->assertSame( $num_queries, $wpdb->num_queries );
     4646                $this->assertSame( $num_queries, get_num_queries() );
    46494647        }
    46504648
    … …  
    46934691                );
    46944692
    4695                 $num_queries = $wpdb->num_queries;
     4693                $num_queries = get_num_queries();
    46964694
    46974695                $q2 = new WP_Comment_Query(
    … …  
    47024700                );
    47034701
    4704                 $this->assertSame( $num_queries, $wpdb->num_queries );
     4702                $this->assertSame( $num_queries, get_num_queries() );
    47054703        }
    47064704
    … …  
    47254723                );
    47264724
    4727                 $num_queries = $wpdb->num_queries;
     4725                $num_queries = get_num_queries();
    47284726
    47294727                $q = new WP_Comment_Query(
    … …  
    47344732                );
    47354733
    4736                 $this->assertSame( $num_queries, $wpdb->num_queries );
     4734                $this->assertSame( $num_queries, get_num_queries() );
    47374735                $this->assertSameSets( array( $c ), $q->comments );
    47384736        }
    … …  
    47674765                );
    47684766
    4769                 $num_queries = $wpdb->num_queries;
     4767                $num_queries = get_num_queries();
    47704768
    47714769                $q = new WP_Comment_Query(
    … …  
    47774775
    47784776                $num_queries++;
    4779                 $this->assertSame( $num_queries, $wpdb->num_queries );
     4777                $this->assertSame( $num_queries, get_num_queries() );
    47804778                $this->assertSameSets( array( $c ), $q->comments );
    47814779        }
    … …  
    48034801                wp_delete_comment( $c );
    48044802
    4805                 $num_queries = $wpdb->num_queries;
     4803                $num_queries = get_num_queries();
    48064804
    48074805                $q = new WP_Comment_Query(
    … …  
    48134811
    48144812                $num_queries++;
    4815                 $this->assertSame( $num_queries, $wpdb->num_queries );
     4813                $this->assertSame( $num_queries, get_num_queries() );
    48164814                $this->assertSameSets( array(), $q->comments );
    48174815        }
    … …  
    48394837                wp_trash_comment( $c );
    48404838
    4841                 $num_queries = $wpdb->num_queries;
     4839                $num_queries = get_num_queries();
    48424840
    48434841                $q = new WP_Comment_Query(
    … …  
    48494847
    48504848                $num_queries++;
    4851                 $this->assertSame( $num_queries, $wpdb->num_queries );
     4849                $this->assertSame( $num_queries, get_num_queries() );
    48524850                $this->assertSameSets( array(), $q->comments );
    48534851        }
    … …  
    48774875                wp_untrash_comment( $c );
    48784876
    4879                 $num_queries = $wpdb->num_queries;
     4877                $num_queries = get_num_queries();
    48804878
    48814879                $q = new WP_Comment_Query(
    … …  
    48874885
    48884886                $num_queries++;
    4889                 $this->assertSame( $num_queries, $wpdb->num_queries );
     4887                $this->assertSame( $num_queries, get_num_queries() );
    48904888                $this->assertSameSets( array( $c ), $q->comments );
    48914889        }
    … …  
    49134911                wp_spam_comment( $c );
    49144912
    4915                 $num_queries = $wpdb->num_queries;
     4913                $num_queries = get_num_queries();
    49164914
    49174915                $q = new WP_Comment_Query(
    … …  
    49234921
    49244922                $num_queries++;
    4925                 $this->assertSame( $num_queries, $wpdb->num_queries );
     4923                $this->assertSame( $num_queries, get_num_queries() );
    49264924                $this->assertSameSets( array(), $q->comments );
    49274925        }
    … …  
    49514949                wp_unspam_comment( $c );
    49524950
    4953                 $num_queries = $wpdb->num_queries;
     4951                $num_queries = get_num_queries();
    49544952
    49554953                $q = new WP_Comment_Query(
    … …  
    49614959
    49624960                $num_queries++;
    4963                 $this->assertSame( $num_queries, $wpdb->num_queries );
     4961                $this->assertSame( $num_queries, get_num_queries() );
    49644962                $this->assertSameSets( array( $c ), $q->comments );
    49654963        }
    … …  
    49834981                );
    49844982
    4985                 $number_of_queries = $wpdb->num_queries;
     4983                $number_of_queries = get_num_queries();
    49864984
    49874985                $query_2 = $q->query(
    … …  
    49934991                        )
    49944992                );
    4995                 $this->assertSame( $number_of_queries + 1, $wpdb->num_queries );
     4993                $this->assertSame( $number_of_queries + 1, get_num_queries() );
    49964994        }
    49974995
    … …  
    50145012                        )
    50155013                );
    5016                 $number_of_queries = $wpdb->num_queries;
     5014                $number_of_queries = get_num_queries();
    50175015
    50185016                $query_2 = $q->query(
    … …  
    50245022                        )
    50255023                );
    5026                 $this->assertSame( $number_of_queries, $wpdb->num_queries );
     5024                $this->assertSame( $number_of_queries, get_num_queries() );
    50275025        }
    50285026
    … …  
    50445042                        )
    50455043                );
    5046                 $number_of_queries = $wpdb->num_queries;
     5044                $number_of_queries = get_num_queries();
    50475045
    50485046                $query_2 = $q->query(
    … …  
    50545052                );
    50555053
    5056                 $this->assertSame( $number_of_queries, $wpdb->num_queries );
     5054                $this->assertSame( $number_of_queries, get_num_queries() );
    50575055        }
    50585056
    … …  
    52205218                add_filter( 'comments_pre_query', array( __CLASS__, 'filter_comments_pre_query' ), 10, 2 );
    52215219
    5222                 $num_queries = $wpdb->num_queries;
     5220                $num_queries = get_num_queries();
    52235221
    52245222                $q       = new WP_Comment_Query();
    … …  
    52285226
    52295227                // Make sure no queries were executed.
    5230                 $this->assertSame( $num_queries, $wpdb->num_queries );
     5228                $this->assertSame( $num_queries, get_num_queries() );
    52315229
    52325230                // We manually inserted a non-existing site and overrode the results with it.

  • trunk/tests/phpunit/tests/comment/wpUpdateCommentCountNow.php

    r54704 r55745  
    1515
    1616        public function test_regular_post_updates_comment_count() {
    17                 global $wpdb;
    18 
    1917                $post_id = self::factory()->post->create();
    2018
    … …  
    2220                $this->assertSame( '1', get_comments_number( $post_id ) );
    2321
    24                 $num_queries = $wpdb->num_queries;
     22                $num_queries = get_num_queries();
    2523                $this->assertTrue( wp_update_comment_count_now( $post_id ) );
    26                 $this->assertSame( $num_queries + 2, $wpdb->num_queries );
     24                $this->assertSame( $num_queries + 2, get_num_queries() );
    2725
    2826                $this->assertSame( '1', get_comments_number( $post_id ) );
    … …  
    3937                $this->assertSame( '100', get_comments_number( $post_id ) );
    4038
    41                 $num_queries = $wpdb->num_queries;
     39                $num_queries = get_num_queries();
    4240                $this->assertTrue( wp_update_comment_count_now( $post_id ) );
    4341                // Only one query is made instead of two.
    44                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     42                $this->assertSame( $num_queries + 1, get_num_queries() );
    4543
    4644                $this->assertSame( '100', get_comments_number( $post_id ) );

  • trunk/tests/phpunit/tests/customize/manager.php

    r55039 r55745  
    272272         */
    273273        public function test_fresh_site_flag_clearing() {
    274                 global $wp_customize, $wpdb;
     274                global $wp_customize;
    275275
    276276                // Make sure fresh site flag is cleared when publishing a changeset.
    … …  
    284284
    285285                // Make sure no DB write is done when publishing and a site is already non-fresh.
    286                 $query_count = $wpdb->num_queries;
     286                $query_count = get_num_queries();
    287287                do_action( 'customize_save_after', $wp_customize );
    288                 $this->assertSame( $query_count, $wpdb->num_queries );
     288                $this->assertSame( $query_count, get_num_queries() );
    289289        }
    290290

  • trunk/tests/phpunit/tests/general/wpGetArchives.php

    r52010 r55745  
    1717         */
    1818        public function test_get_archives_cache() {
    19                 global $wpdb;
    20 
    2119                self::factory()->post->create_many( 3, array( 'post_type' => 'post' ) );
    2220                wp_cache_delete( 'last_changed', 'posts' );
    2321                $this->assertFalse( wp_cache_get( 'last_changed', 'posts' ) );
    2422
    25                 $num_queries = $wpdb->num_queries;
     23                $num_queries = get_num_queries();
    2624
    2725                // Cache is not primed, expect 1 query.
    … …  
    3533                $time1 = wp_cache_get( 'last_changed', 'posts' );
    3634                $this->assertNotEmpty( $time1 );
    37                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     35                $this->assertSame( $num_queries + 1, get_num_queries() );
    3836
    39                 $num_queries = $wpdb->num_queries;
     37                $num_queries = get_num_queries();
    4038
    4139                // Cache is primed, expect no queries.
    … …  
    4846                $this->assertIsString( $result );
    4947                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    50                 $this->assertSame( $num_queries, $wpdb->num_queries );
     48                $this->assertSame( $num_queries, get_num_queries() );
    5149
    5250                // Change args, resulting in a different query string. Cache is not primed, expect 1 query.
    … …  
    6058                $this->assertIsString( $result );
    6159                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    62                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     60                $this->assertSame( $num_queries + 1, get_num_queries() );
    6361
    64                 $num_queries = $wpdb->num_queries;
     62                $num_queries = get_num_queries();
    6563
    6664                // Cache is primed, expect no queries.
    … …  
    7472                $this->assertIsString( $result );
    7573                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    76                 $this->assertSame( $num_queries, $wpdb->num_queries );
     74                $this->assertSame( $num_queries, get_num_queries() );
    7775
    78                 $num_queries = $wpdb->num_queries;
     76                $num_queries = get_num_queries();
    7977
    8078                // Change type. Cache is not primed, expect 1 query.
    … …  
    8785                $this->assertIsString( $result );
    8886                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    89                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     87                $this->assertSame( $num_queries + 1, get_num_queries() );
    9088
    91                 $num_queries = $wpdb->num_queries;
     89                $num_queries = get_num_queries();
    9290
    9391                // Cache is primed, expect no queries.
    … …  
    10098                $this->assertIsString( $result );
    10199                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    102                 $this->assertSame( $num_queries, $wpdb->num_queries );
     100                $this->assertSame( $num_queries, get_num_queries() );
    103101
    104102                // Change type. Cache is not primed, expect 1 query.
    … …  
    111109                $this->assertIsString( $result );
    112110                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    113                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     111                $this->assertSame( $num_queries + 1, get_num_queries() );
    114112
    115                 $num_queries = $wpdb->num_queries;
     113                $num_queries = get_num_queries();
    116114
    117115                // Cache is primed, expect no queries.
    … …  
    124122                $this->assertIsString( $result );
    125123                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    126                 $this->assertSame( $num_queries, $wpdb->num_queries );
     124                $this->assertSame( $num_queries, get_num_queries() );
    127125
    128126                // Change type. Cache is not primed, expect 1 query.
    … …  
    135133                $this->assertIsString( $result );
    136134                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    137                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     135                $this->assertSame( $num_queries + 1, get_num_queries() );
    138136
    139                 $num_queries = $wpdb->num_queries;
     137                $num_queries = get_num_queries();
    140138
    141139                // Cache is primed, expect no queries.
    … …  
    148146                $this->assertIsString( $result );
    149147                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    150                 $this->assertSame( $num_queries, $wpdb->num_queries );
     148                $this->assertSame( $num_queries, get_num_queries() );
    151149
    152150                // Change type. Cache is not primed, expect 1 query.
    … …  
    159157                $this->assertIsString( $result );
    160158                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    161                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     159                $this->assertSame( $num_queries + 1, get_num_queries() );
    162160
    163                 $num_queries = $wpdb->num_queries;
     161                $num_queries = get_num_queries();
    164162
    165163                // Cache is primed, expect no queries.
    … …  
    172170                $this->assertIsString( $result );
    173171                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    174                 $this->assertSame( $num_queries, $wpdb->num_queries );
     172                $this->assertSame( $num_queries, get_num_queries() );
    175173        }
    176174}

  • trunk/tests/phpunit/tests/multisite/network.php

    r54637 r55745  
    591591                 */
    592592                public function test_get_network_not_found_cache() {
    593                         global $wpdb;
    594 
    595593                        $new_network_id = $this->_get_next_network_id();
    596594                        $this->assertNull( get_network( $new_network_id ) );
    597595
    598                         $num_queries = $wpdb->num_queries;
     596                        $num_queries = get_num_queries();
    599597                        $this->assertNull( get_network( $new_network_id ) );
    600                         $this->assertSame( $num_queries, $wpdb->num_queries );
     598                        $this->assertSame( $num_queries, get_num_queries() );
    601599                }
    602600

  • trunk/tests/phpunit/tests/multisite/site.php

    r55043 r55745  
    21712171                 */
    21722172                public function test_get_site_not_found_cache() {
    2173                         global $wpdb;
    2174 
    21752173                        $new_site_id = $this->_get_next_site_id();
    21762174                        $this->assertNull( get_site( $new_site_id ) );
    21772175
    2178                         $num_queries = $wpdb->num_queries;
     2176                        $num_queries = get_num_queries();
    21792177                        $this->assertNull( get_site( $new_site_id ) );
    2180                         $this->assertSame( $num_queries, $wpdb->num_queries );
     2178                        $this->assertSame( $num_queries, get_num_queries() );
    21812179                }
    21822180

  • trunk/tests/phpunit/tests/multisite/siteMeta.php

    r51860 r55745  
    221221
    222222                public function test_update_site_meta_cache() {
    223                         global $wpdb;
    224 
    225223                        if ( ! is_site_meta_supported() ) {
    226224                                $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    … …  
    230228                        update_sitemeta_cache( array( self::$site_id ) );
    231229
    232                         $num_queries = $wpdb->num_queries;
     230                        $num_queries = get_num_queries();
    233231                        get_site_meta( self::$site_id, 'foo', true );
    234                         $this->assertSame( $num_queries, $wpdb->num_queries );
     232                        $this->assertSame( $num_queries, get_num_queries() );
    235233                }
    236234
    237235                public function test_query_update_site_meta_cache_true() {
    238                         global $wpdb;
    239 
    240236                        if ( ! is_site_meta_supported() ) {
    241237                                $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    … …  
    251247                        );
    252248
    253                         $num_queries = $wpdb->num_queries;
     249                        $num_queries = get_num_queries();
    254250                        get_site_meta( self::$site_id, 'foo', true );
    255                         $this->assertSame( $num_queries, $wpdb->num_queries );
     251                        $this->assertSame( $num_queries, get_num_queries() );
    256252                }
    257253
    258254                public function test_query_update_site_meta_cache_false() {
    259                         global $wpdb;
    260 
    261255                        if ( ! is_site_meta_supported() ) {
    262256                                $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    … …  
    272266                        );
    273267
    274                         $num_queries = $wpdb->num_queries;
     268                        $num_queries = get_num_queries();
    275269                        get_site_meta( self::$site_id, 'foo', true );
    276                         $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     270                        $this->assertSame( $num_queries + 1, get_num_queries() );
    277271                }
    278272

  • trunk/tests/phpunit/tests/multisite/wpNetworkQuery.php

    r53098 r55745  
    429429                 */
    430430                public function test_wp_network_query_cache_with_different_fields_no_count() {
    431                         global $wpdb;
    432 
    433431                        $q                 = new WP_Network_Query();
    434432                        $query_1           = $q->query(
    … …  
    439437                                )
    440438                        );
    441                         $number_of_queries = $wpdb->num_queries;
     439                        $number_of_queries = get_num_queries();
    442440
    443441                        $query_2 = $q->query(
    … …  
    449447                        );
    450448
    451                         $this->assertSame( $number_of_queries, $wpdb->num_queries );
     449                        $this->assertSame( $number_of_queries, get_num_queries() );
    452450                }
    453451
    … …  
    456454                 */
    457455                public function test_wp_network_query_cache_with_different_fields_active_count() {
    458                         global $wpdb;
    459 
    460456                        $q = new WP_Network_Query();
    461457
    … …  
    468464                                )
    469465                        );
    470                         $number_of_queries = $wpdb->num_queries;
     466                        $number_of_queries = get_num_queries();
    471467
    472468                        $query_2 = $q->query(
    … …  
    478474                                )
    479475                        );
    480                         $this->assertSame( $number_of_queries, $wpdb->num_queries );
     476                        $this->assertSame( $number_of_queries, get_num_queries() );
    481477                }
    482478
    … …  
    485481                 */
    486482                public function test_wp_network_query_cache_with_same_fields_different_count() {
    487                         global $wpdb;
    488 
    489483                        $q = new WP_Network_Query();
    490484
    … …  
    497491                        );
    498492
    499                         $number_of_queries = $wpdb->num_queries;
     493                        $number_of_queries = get_num_queries();
    500494
    501495                        $query_2 = $q->query(
    … …  
    507501                                )
    508502                        );
    509                         $this->assertSame( $number_of_queries + 1, $wpdb->num_queries );
     503                        $this->assertSame( $number_of_queries + 1, get_num_queries() );
    510504                }
    511505
    … …  
    569563                 */
    570564                public function test_networks_pre_query_filter_should_bypass_database_query() {
    571                         global $wpdb;
    572 
    573565                        add_filter( 'networks_pre_query', array( __CLASS__, 'filter_networks_pre_query' ), 10, 2 );
    574566
    575                         $num_queries = $wpdb->num_queries;
     567                        $num_queries = get_num_queries();
    576568
    577569                        $q       = new WP_Network_Query();
    … …  
    581573
    582574                        // Make sure no queries were executed.
    583                         $this->assertSame( $num_queries, $wpdb->num_queries );
     575                        $this->assertSame( $num_queries, get_num_queries() );
    584576
    585577                        // We manually inserted a non-existing site and overrode the results with it.

  • trunk/tests/phpunit/tests/multisite/wpSiteQuery.php

    r53097 r55745  
    780780                 */
    781781                public function test_wp_site_query_cache_with_different_fields_no_count() {
    782                         global $wpdb;
    783782                        $q                 = new WP_Site_Query();
    784783                        $query_1           = $q->query(
    … …  
    790789                                )
    791790                        );
    792                         $number_of_queries = $wpdb->num_queries;
     791                        $number_of_queries = get_num_queries();
    793792
    794793                        $query_2 = $q->query(
    … …  
    801800                        );
    802801
    803                         $this->assertSame( $number_of_queries, $wpdb->num_queries );
     802                        $this->assertSame( $number_of_queries, get_num_queries() );
    804803                }
    805804
    … …  
    808807                 */
    809808                public function test_wp_site_query_cache_with_different_fields_active_count() {
    810                         global $wpdb;
    811809                        $q = new WP_Site_Query();
    812810
    … …  
    820818                                )
    821819                        );
    822                         $number_of_queries = $wpdb->num_queries;
     820                        $number_of_queries = get_num_queries();
    823821
    824822                        $query_2 = $q->query(
    … …  
    831829                                )
    832830                        );
    833                         $this->assertSame( $number_of_queries, $wpdb->num_queries );
     831                        $this->assertSame( $number_of_queries, get_num_queries() );
    834832                }
    835833
    … …  
    838836                 */
    839837                public function test_wp_site_query_cache_with_same_fields_different_count() {
    840                         global $wpdb;
    841838                        $q = new WP_Site_Query();
    842839
    … …  
    861858                                )
    862859                        );
    863                         $this->assertSame( $number_of_queries + 1, $wpdb->num_queries );
     860                        $this->assertSame( $number_of_queries + 1, get_num_queries() );
    864861                }
    865862
    … …  
    11201117                 */
    11211118                public function test_sites_pre_query_filter_should_bypass_database_query() {
    1122                         global $wpdb;
    1123 
    11241119                        add_filter( 'sites_pre_query', array( __CLASS__, 'filter_sites_pre_query' ), 10, 2 );
    11251120
    1126                         $num_queries = $wpdb->num_queries;
     1121                        $num_queries = get_num_queries();
    11271122
    11281123                        $q       = new WP_Site_Query();
    … …  
    11321127
    11331128                        // Make sure no queries were executed.
    1134                         $this->assertSame( $num_queries, $wpdb->num_queries );
     1129                        $this->assertSame( $num_queries, get_num_queries() );
    11351130
    11361131                        // We manually inserted a non-existing site and overrode the results with it.

  • trunk/tests/phpunit/tests/option/updateOption.php

    r53865 r55745  
    2929         */
    3030        public function test_should_set_autoload_yes_for_nonexistent_option_when_autoload_param_is_missing() {
    31                 global $wpdb;
    3231                $this->flush_cache();
    3332                update_option( 'test_update_option_default', 'value' );
    … …  
    3736                wp_load_alloptions();
    3837
    39                 $before = $wpdb->num_queries;
    40                 $value  = get_option( 'test_update_option_default' );
    41                 $after  = $wpdb->num_queries;
     38                $before = get_num_queries();
     39                $value  = get_option( 'test_update_option_default' );
     40                $after  = get_num_queries();
    4241
    4342                $this->assertSame( $before, $after );
    … …  
    5352         */
    5453        public function test_should_set_autoload_yes_for_nonexistent_option_when_autoload_param_is_yes() {
    55                 global $wpdb;
    5654                $this->flush_cache();
    5755                update_option( 'test_update_option_default', 'value', 'yes' );
    … …  
    6159                wp_load_alloptions();
    6260
    63                 $before = $wpdb->num_queries;
    64                 $value  = get_option( 'test_update_option_default' );
    65                 $after  = $wpdb->num_queries;
     61                $before = get_num_queries();
     62                $value  = get_option( 'test_update_option_default' );
     63                $after  = get_num_queries();
    6664
    6765                $this->assertSame( $before, $after );
    … …  
    7775         */
    7876        public function test_should_set_autoload_no_for_nonexistent_option_when_autoload_param_is_no() {
    79                 global $wpdb;
    8077                $this->flush_cache();
    8178                update_option( 'test_update_option_default', 'value', 'no' );
    … …  
    8582                wp_load_alloptions();
    8683
    87                 $before = $wpdb->num_queries;
    88                 $value  = get_option( 'test_update_option_default' );
    89                 $after  = $wpdb->num_queries;
     84                $before = get_num_queries();
     85                $value  = get_option( 'test_update_option_default' );
     86                $after  = get_num_queries();
    9087
    9188                // Database has been hit.
    … …  
    10299         */
    103100        public function test_should_set_autoload_no_for_nonexistent_option_when_autoload_param_is_false() {
    104                 global $wpdb;
    105101                $this->flush_cache();
    106102                update_option( 'test_update_option_default', 'value', false );
    … …  
    110106                wp_load_alloptions();
    111107
    112                 $before = $wpdb->num_queries;
    113                 $value  = get_option( 'test_update_option_default' );
    114                 $after  = $wpdb->num_queries;
     108                $before = get_num_queries();
     109                $value  = get_option( 'test_update_option_default' );
     110                $after  = get_num_queries();
    115111
    116112                // Database has been hit.
    … …  
    127123         */
    128124        public function test_autoload_should_be_updated_for_existing_option_when_value_is_changed() {
    129                 global $wpdb;
    130125                add_option( 'foo', 'bar', '', 'no' );
    131126                $updated = update_option( 'foo', 'bar2', true );
    … …  
    137132                wp_load_alloptions();
    138133
    139                 $before = $wpdb->num_queries;
     134                $before = get_num_queries();
    140135                $value  = get_option( 'foo' );
    141136
    142                 $this->assertSame( $before, $wpdb->num_queries );
     137                $this->assertSame( $before, get_num_queries() );
    143138                $this->assertSame( $value, 'bar2' );
    144139        }
    … …  
    152147         */
    153148        public function test_autoload_should_not_be_updated_for_existing_option_when_value_is_unchanged() {
    154                 global $wpdb;
    155149                add_option( 'foo', 'bar', '', 'yes' );
    156150                $updated = update_option( 'foo', 'bar', false );
    … …  
    162156                wp_load_alloptions();
    163157
    164                 $before = $wpdb->num_queries;
     158                $before = get_num_queries();
    165159                $value  = get_option( 'foo' );
    166160
    167161                // 'foo' should still be autoload=yes, so we should see no additional querios.
    168                 $this->assertSame( $before, $wpdb->num_queries );
     162                $this->assertSame( $before, get_num_queries() );
    169163                $this->assertSame( $value, 'bar' );
    170164        }
    … …  
    178172         */
    179173        public function test_autoload_should_not_be_updated_for_existing_option_when_value_is_changed_but_no_value_of_autoload_is_provided() {
    180                 global $wpdb;
    181174                add_option( 'foo', 'bar', '', 'yes' );
    182175
    … …  
    190183                wp_load_alloptions();
    191184
    192                 $before = $wpdb->num_queries;
     185                $before = get_num_queries();
    193186                $value  = get_option( 'foo' );
    194187
    195188                // 'foo' should still be autoload=yes, so we should see no additional queries.
    196                 $this->assertSame( $before, $wpdb->num_queries );
     189                $this->assertSame( $before, get_num_queries() );
    197190                $this->assertSame( $value, 'bar2' );
    198191        }

  • trunk/tests/phpunit/tests/option/wpLoadAlloptions.php

    r55256 r55745  
    3535         */
    3636        public function test_if_alloptions_are_retrieved_from_cache() {
    37                 global $wpdb;
    38                 $before = $wpdb->num_queries;
     37                $before = get_num_queries();
    3938                wp_load_alloptions();
    40                 $after = $wpdb->num_queries;
     39                $after = get_num_queries();
    4140
    4241                // Database has not been hit.
    … …  
    5049         */
    5150        public function test_if_alloptions_are_retrieved_from_database() {
    52                 global $wpdb;
    53 
    5451                // Delete the existing cache first.
    5552                wp_cache_delete( 'alloptions', 'options' );
    5653
    57                 $before = $wpdb->num_queries;
     54                $before = get_num_queries();
    5855                wp_load_alloptions();
    59                 $after = $wpdb->num_queries;
     56                $after = get_num_queries();
    6057
    6158                // Database has been hit.

  • trunk/tests/phpunit/tests/post/getPageByPath.php

    r55169 r55745  
    261261         */
    262262        public function test_should_hit_cache() {
    263                 global $wpdb;
    264 
    265263                $page = self::factory()->post->create(
    266264                        array(
    … …  
    274272                $this->assertSame( $page, $found->ID );
    275273
    276                 $num_queries = $wpdb->num_queries;
    277 
    278                 $found = get_page_by_path( 'foo' );
    279                 $this->assertSame( $page, $found->ID );
    280                 $this->assertSame( $num_queries, $wpdb->num_queries );
     274                $num_queries = get_num_queries();
     275
     276                $found = get_page_by_path( 'foo' );
     277                $this->assertSame( $page, $found->ID );
     278                $this->assertSame( $num_queries, get_num_queries() );
    281279        }
    282280
    … …  
    285283         */
    286284        public function test_bad_path_should_be_cached() {
    287                 global $wpdb;
    288 
    289285                // Prime cache.
    290286                $found = get_page_by_path( 'foo' );
    291287                $this->assertNull( $found );
    292288
    293                 $num_queries = $wpdb->num_queries;
    294 
    295                 $found = get_page_by_path( 'foo' );
    296                 $this->assertNull( $found );
    297                 $this->assertSame( $num_queries, $wpdb->num_queries );
     289                $num_queries = get_num_queries();
     290
     291                $found = get_page_by_path( 'foo' );
     292                $this->assertNull( $found );
     293                $this->assertSame( $num_queries, get_num_queries() );
    298294        }
    299295
    … …  
    302298         */
    303299        public function test_bad_path_served_from_cache_should_not_fall_back_on_current_post() {
    304                 global $wpdb, $post;
     300                global $post;
    305301
    306302                // Fake the global.
    … …  
    311307                $this->assertNull( $found );
    312308
    313                 $num_queries = $wpdb->num_queries;
    314 
    315                 $found = get_page_by_path( 'foo' );
    316                 $this->assertNull( $found );
    317                 $this->assertSame( $num_queries, $wpdb->num_queries );
     309                $num_queries = get_num_queries();
     310
     311                $found = get_page_by_path( 'foo' );
     312                $this->assertNull( $found );
     313                $this->assertSame( $num_queries, get_num_queries() );
    318314
    319315                unset( $post );
    … …  
    324320         */
    325321        public function test_cache_should_not_match_post_in_different_post_type_with_same_path() {
    326                 global $wpdb;
    327 
    328322                register_post_type( 'wptests_pt' );
    329323
    … …  
    346340                $this->assertSame( $p1, $found->ID );
    347341
    348                 $num_queries = $wpdb->num_queries;
     342                $num_queries = get_num_queries();
    349343
    350344                $found = get_page_by_path( 'foo', OBJECT, 'wptests_pt' );
    351345                $this->assertSame( $p2, $found->ID );
    352346                $num_queries++;
    353                 $this->assertSame( $num_queries, $wpdb->num_queries );
     347                $this->assertSame( $num_queries, get_num_queries() );
    354348        }
    355349
    … …  
    358352         */
    359353        public function test_cache_should_be_invalidated_when_post_name_is_edited() {
    360                 global $wpdb;
    361 
    362354                $page = self::factory()->post->create(
    363355                        array(
    … …  
    378370                );
    379371
    380                 $num_queries = $wpdb->num_queries;
     372                $num_queries = get_num_queries();
    381373
    382374                $found = get_page_by_path( 'bar' );
    383375                $this->assertSame( $page, $found->ID );
    384376                $num_queries++;
    385                 $this->assertSame( $num_queries, $wpdb->num_queries );
     377                $this->assertSame( $num_queries, get_num_queries() );
    386378        }
    387379

  • trunk/tests/phpunit/tests/post/getPages.php

    r55590 r55745  
    1111         */
    1212        public function test_get_pages_cache() {
    13                 global $wpdb;
    14 
    1513                self::factory()->post->create_many( 3, array( 'post_type' => 'page' ) );
    1614                wp_cache_delete( 'last_changed', 'posts' );
    … …  
    2119                $time1 = wp_cache_get( 'last_changed', 'posts' );
    2220                $this->assertNotEmpty( $time1 );
    23                 $num_queries = $wpdb->num_queries;
     21                $num_queries = get_num_queries();
    2422                foreach ( $pages as $page ) {
    2523                        $this->assertInstanceOf( 'WP_Post', $page );
    … …  
    3028                $this->assertCount( 3, $pages );
    3129                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    32                 $this->assertSame( $num_queries, $wpdb->num_queries );
     30                $this->assertSame( $num_queries, get_num_queries() );
    3331                foreach ( $pages as $page ) {
    3432                        $this->assertInstanceOf( 'WP_Post', $page );
    … …  
    4038                $this->assertCount( 2, $pages );
    4139                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    42                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     40                $this->assertSame( $num_queries + 1, get_num_queries() );
    4341                foreach ( $pages as $page ) {
    4442                        $this->assertInstanceOf( 'WP_Post', $page );
    4543                }
    4644
    47                 $num_queries = $wpdb->num_queries;
     45                $num_queries = get_num_queries();
    4846
    4947                // Again. num_queries and last_changed should remain the same.
    … …  
    5149                $this->assertCount( 2, $pages );
    5250                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    53                 $this->assertSame( $num_queries, $wpdb->num_queries );
     51                $this->assertSame( $num_queries, get_num_queries() );
    5452                foreach ( $pages as $page ) {
    5553                        $this->assertInstanceOf( 'WP_Post', $page );
    … …  
    6058                $this->assertCount( 3, $pages );
    6159                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'posts' ) );
    62                 $this->assertSame( $num_queries, $wpdb->num_queries );
     60                $this->assertSame( $num_queries, get_num_queries() );
    6361                foreach ( $pages as $page ) {
    6462                        $this->assertInstanceOf( 'WP_Post', $page );
    … …  
    6967                $this->assertNotEquals( $time1, $time2 = wp_cache_get( 'last_changed', 'posts' ) );
    7068                get_post( $pages[0]->ID );
    71                 $num_queries = $wpdb->num_queries;
     69                $num_queries = get_num_queries();
    7270
    7371                // last_changed bumped so num_queries should increment.
    … …  
    7573                $this->assertCount( 2, $pages );
    7674                $this->assertSame( $time2, wp_cache_get( 'last_changed', 'posts' ) );
    77                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     75                $this->assertSame( $num_queries + 1, get_num_queries() );
    7876                foreach ( $pages as $page ) {
    7977                        $this->assertInstanceOf( 'WP_Post', $page );
    … …  
    8886                $this->assertGreaterThan( $old_changed_float, $new_changed_float );
    8987
    90                 $num_queries  = $wpdb->num_queries;
     88                $num_queries  = get_num_queries();
    9189                $last_changed = wp_cache_get( 'last_changed', 'posts' );
    9290
    … …  
    9593                $this->assertCount( 2, $pages );
    9694                $this->assertSame( $last_changed, wp_cache_get( 'last_changed', 'posts' ) );
    97                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     95                $this->assertSame( $num_queries + 1, get_num_queries() );
    9896                foreach ( $pages as $page ) {
    9997                        $this->assertInstanceOf( 'WP_Post', $page );
    … …  
    105103         */
    106104        public function test_get_pages_cache_empty() {
    107                 global $wpdb;
    108 
    109105                wp_cache_delete( 'last_changed', 'posts' );
    110106                $this->assertFalse( wp_cache_get( 'last_changed', 'posts' ) );
    111107
    112                 $num_queries = $wpdb->num_queries;
     108                $num_queries = get_num_queries();
    113109
    114110                $pages = get_pages(); // Database gets queried.
    115111
    116                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
    117 
    118                 $num_queries = $wpdb->num_queries;
     112                $this->assertSame( $num_queries + 1, get_num_queries() );
     113
     114                $num_queries = get_num_queries();
    119115
    120116                $pages = get_pages(); // Database should not get queried.
    121117
    122                 $this->assertSame( $num_queries, $wpdb->num_queries );
     118                $this->assertSame( $num_queries, get_num_queries() );
    123119        }
    124120

  • trunk/tests/phpunit/tests/post/getPostClass.php

    r51568 r55745  
    122122         */
    123123        public function test_taxonomy_classes_hit_cache() {
    124                 global $wpdb;
    125 
    126124                register_taxonomy( 'wptests_tax', 'post' );
    127125                wp_set_post_terms( $this->post_id, array( 'foo', 'bar' ), 'wptests_tax' );
    … …  
    132130                update_meta_cache( 'post', $this->post_id );
    133131
    134                 $num_queries = $wpdb->num_queries;
     132                $num_queries = get_num_queries();
    135133
    136134                $found = get_post_class( '', $this->post_id );
    137135
    138                 $this->assertSame( $num_queries, $wpdb->num_queries );
     136                $this->assertSame( $num_queries, get_num_queries() );
    139137        }
    140138}

  • trunk/tests/phpunit/tests/post/query.php

    r55562 r55745  
    556556         */
    557557        public function test_posts_pre_query_filter_should_bypass_database_query() {
    558                 global $wpdb;
    559 
    560558                add_filter( 'posts_pre_query', array( __CLASS__, 'filter_posts_pre_query' ) );
    561559
    562                 $num_queries = $wpdb->num_queries;
     560                $num_queries = get_num_queries();
    563561                $q           = new WP_Query(
    564562                        array(
    … …  
    570568                remove_filter( 'posts_pre_query', array( __CLASS__, 'filter_posts_pre_query' ) );
    571569
    572                 $this->assertSame( $num_queries, $wpdb->num_queries );
     570                $this->assertSame( $num_queries, get_num_queries() );
    573571                $this->assertSame( array( 12345 ), $q->posts );
    574572        }

  • trunk/tests/phpunit/tests/query/commentFeed.php

    r53941 r55745  
    2929         */
    3030        public function test_archive_comment_feed() {
    31                 global $wpdb;
    3231                add_filter( 'split_the_query', '__return_false' );
    3332                $q1   = new WP_Query();
    … …  
    4342                );
    4443                $q1->query( $args );
    45                 $num_queries = $wpdb->num_queries;
     44                $num_queries = get_num_queries();
    4645                $q2          = new WP_Query();
    4746                $q2->query( $args );
    4847                $this->assertTrue( $q2->is_comment_feed() );
    4948                $this->assertFalse( $q2->is_singular() );
    50                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     49                $this->assertSame( $num_queries + 1, get_num_queries() );
    5150        }
    5251
    … …  
    8887         */
    8988        public function test_single_comment_feed() {
    90                 global $wpdb;
    9189                $post = get_post( self::$post_ids[0] );
    9290
    … …  
    104102
    105103                $q1->query( $args );
    106                 $num_queries = $wpdb->num_queries;
     104                $num_queries = get_num_queries();
    107105                $q2          = new WP_Query();
    108106                $q2->query( $args );
    … …  
    110108                $this->assertTrue( $q2->is_comment_feed() );
    111109                $this->assertTrue( $q2->is_singular() );
    112                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     110                $this->assertSame( $num_queries + 1, get_num_queries() );
    113111        }
    114112}

  • trunk/tests/phpunit/tests/rest-api/rest-tags-controller.php

    r55457 r55745  
    13371337         */
    13381338        public function test_object_term_queries_are_cached() {
    1339                 global $wpdb;
    1340 
    13411339                $tags = self::factory()->tag->create_many( 2 );
    13421340                $p    = self::factory()->post->create();
    … …  
    13501348                unset( $request, $response );
    13511349
    1352                 $num_queries = $wpdb->num_queries;
     1350                $num_queries = get_num_queries();
    13531351
    13541352                $request = new WP_REST_Request( 'GET', '/wp/v2/tags' );
    … …  
    13581356
    13591357                $this->assertSameSets( $found_1, $found_2 );
    1360                 $this->assertSame( $num_queries, $wpdb->num_queries );
     1358                $this->assertSame( $num_queries, get_num_queries() );
    13611359        }
    13621360

  • trunk/tests/phpunit/tests/term/cache.php

    r54090 r55745  
    102102
    103103        public function test_get_term_should_update_term_cache_when_passed_an_object() {
    104                 global $wpdb;
    105 
    106104                register_taxonomy( 'wptests_tax', 'post' );
    107105                $term = self::factory()->term->create(
    … …  
    117115                $this->assertEmpty( wp_cache_get( $term, 'terms' ) );
    118116
    119                 $num_queries = $wpdb->num_queries;
     117                $num_queries = get_num_queries();
    120118
    121119                // get_term() will only be update the cache if the 'filter' prop is unset.
    … …  
    125123
    126124                // No new queries should have fired.
    127                 $this->assertSame( $num_queries, $wpdb->num_queries );
     125                $this->assertSame( $num_queries, get_num_queries() );
    128126                $this->assertSame( $term_object, $term_object_2 );
    129127        }
    130128
    131129        public function test_get_term_should_update_term_cache_when_passed_a_valid_term_identifier() {
    132                 global $wpdb;
    133 
    134130                register_taxonomy( 'wptests_tax', 'post' );
    135131                $term = self::factory()->term->create(
    … …  
    144140                $this->assertEmpty( wp_cache_get( $term, 'terms' ) );
    145141
    146                 $num_queries = $wpdb->num_queries;
     142                $num_queries = get_num_queries();
    147143
    148144                // Prime cache.
    149145                $term_object = get_term( $term, 'wptests_tax' );
    150146                $this->assertNotEmpty( wp_cache_get( $term, 'terms' ) );
    151                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     147                $this->assertSame( $num_queries + 1, get_num_queries() );
    152148
    153149                $term_object_2 = get_term( $term, 'wptests_tax' );
    154150
    155151                // No new queries should have fired.
    156                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     152                $this->assertSame( $num_queries + 1, get_num_queries() );
    157153                $this->assertEquals( $term_object, $term_object_2 );
    158154        }
    159155
    160156        public function test_get_term_by_should_update_term_cache_when_passed_a_valid_term_identifier() {
    161                 global $wpdb;
    162 
    163157                register_taxonomy( 'wptests_tax', 'post' );
    164158                $term = self::factory()->term->create(
    … …  
    173167                $this->assertEmpty( wp_cache_get( $term, 'terms' ) );
    174168
    175                 $num_queries = $wpdb->num_queries;
     169                $num_queries = get_num_queries();
    176170
    177171                // Prime cache.
    178172                $term_object = get_term_by( 'id', $term, 'wptests_tax' );
    179173                $this->assertNotEmpty( wp_cache_get( $term, 'terms' ) );
    180                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     174                $this->assertSame( $num_queries + 1, get_num_queries() );
    181175
    182176                $term_object_2 = get_term( $term, 'wptests_tax' );
    183177
    184178                // No new queries should have fired.
    185                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     179                $this->assertSame( $num_queries + 1, get_num_queries() );
    186180                $this->assertEquals( $term_object, $term_object_2 );
    187181        }
    … …  
    191185         */
    192186        public function test_get_terms_should_update_cache_for_located_terms() {
    193                 global $wpdb;
    194 
    195187                register_taxonomy( 'wptests_tax', 'post' );
    196188
    … …  
    209201                );
    210202
    211                 $num_queries = $wpdb->num_queries;
     203                $num_queries = get_num_queries();
    212204
    213205                foreach ( $terms as $term_id ) {
    … …  
    215207                }
    216208
    217                 $this->assertSame( $num_queries, $wpdb->num_queries );
     209                $this->assertSame( $num_queries, get_num_queries() );
    218210
    219211                _unregister_taxonomy( 'wptests_tax' );
    … …  
    243235         */
    244236        public function test_get_term_by_slug_cache() {
    245                 global $wpdb;
    246 
    247237                $term_id = self::factory()->term->create(
    248238                        array(
    … …  
    254244
    255245                clean_term_cache( $term_id, 'post_tag' );
    256                 $num_queries = $wpdb->num_queries;
     246                $num_queries = get_num_queries();
    257247
    258248                $term        = get_term_by( 'slug', 'burrito', 'post_tag' );
    259249                $num_queries = $num_queries + 2;
    260250                $this->assertSame( 'Taco', $term->name );
    261                 $this->assertSame( $num_queries, $wpdb->num_queries );
     251                $this->assertSame( $num_queries, get_num_queries() );
    262252
    263253                // This should now hit cache.
    264254                $term = get_term_by( 'slug', 'burrito', 'post_tag' );
    265255                $this->assertSame( 'Taco', $term->name );
    266                 $this->assertSame( $num_queries, $wpdb->num_queries );
     256                $this->assertSame( $num_queries, get_num_queries() );
    267257
    268258                $this->assertEquals( get_term( $term_id, 'post_tag' ), $term );
    269                 $this->assertSame( $num_queries, $wpdb->num_queries );
     259                $this->assertSame( $num_queries, get_num_queries() );
    270260        }
    271261
    … …  
    274264         */
    275265        public function test_get_term_by_slug_cache_update() {
    276                 global $wpdb;
    277 
    278266                $term_id = self::factory()->term->create(
    279267                        array(
    … …  
    285273
    286274                clean_term_cache( $term_id, 'post_tag' );
    287                 $num_queries = $wpdb->num_queries;
     275                $num_queries = get_num_queries();
    288276
    289277                $term        = get_term_by( 'slug', 'burrito', 'post_tag' );
    290278                $num_queries = $num_queries + 2;
    291279                $this->assertSame( 'Taco', $term->name );
    292                 $this->assertSame( $num_queries, $wpdb->num_queries );
     280                $this->assertSame( $num_queries, get_num_queries() );
    293281
    294282                // This should now hit cache.
    295283                $term = get_term_by( 'slug', 'burrito', 'post_tag' );
    296284                $this->assertSame( 'Taco', $term->name );
    297                 $this->assertSame( $num_queries, $wpdb->num_queries );
     285                $this->assertSame( $num_queries, get_num_queries() );
    298286
    299287                // Update the tag which invalidates the cache.
    300288                wp_update_term( $term_id, 'post_tag', array( 'name' => 'No Taco' ) );
    301                 $num_queries = $wpdb->num_queries;
     289                $num_queries = get_num_queries();
    302290
    303291                // This should not hit cache.
    … …  
    305293                $num_queries = $num_queries + 2;
    306294                $this->assertSame( 'No Taco', $term->name );
    307                 $this->assertSame( $num_queries, $wpdb->num_queries );
     295                $this->assertSame( $num_queries, get_num_queries() );
    308296        }
    309297
    … …  
    312300         */
    313301        public function test_get_term_by_name_cache() {
    314                 global $wpdb;
    315 
    316302                $term_id = self::factory()->term->create(
    317303                        array(
    … …  
    323309
    324310                clean_term_cache( $term_id, 'post_tag' );
    325                 $num_queries = $wpdb->num_queries;
     311                $num_queries = get_num_queries();
    326312
    327313                get_term_by( 'name', 'Burrito', 'post_tag' );
    328314                $num_queries = $num_queries + 2;
    329                 $this->assertSame( $num_queries, $wpdb->num_queries );
     315                $this->assertSame( $num_queries, get_num_queries() );
    330316
    331317                // This should now hit cache.
    332318                $term = get_term_by( 'name', 'Burrito', 'post_tag' );
    333                 $this->assertSame( $num_queries, $wpdb->num_queries );
     319                $this->assertSame( $num_queries, get_num_queries() );
    334320
    335321                $this->assertEquals( get_term( $term_id, 'post_tag' ), $term );
    336                 $this->assertSame( $num_queries, $wpdb->num_queries );
     322                $this->assertSame( $num_queries, get_num_queries() );
    337323        }
    338324
    … …  
    341327         */
    342328        public function test_get_term_by_name_cache_update() {
    343                 global $wpdb;
    344 
    345329                $term_id = self::factory()->term->create(
    346330                        array(
    … …  
    352336
    353337                clean_term_cache( $term_id, 'post_tag' );
    354                 $num_queries = $wpdb->num_queries;
     338                $num_queries = get_num_queries();
    355339
    356340                get_term_by( 'name', 'Burrito', 'post_tag' );
    357341                $num_queries = $num_queries + 2;
    358                 $this->assertSame( $num_queries, $wpdb->num_queries );
     342                $this->assertSame( $num_queries, get_num_queries() );
    359343
    360344                // This should now hit cache.
    361345                get_term_by( 'name', 'Burrito', 'post_tag' );
    362                 $this->assertSame( $num_queries, $wpdb->num_queries );
     346                $this->assertSame( $num_queries, get_num_queries() );
    363347
    364348                // Update the tag which invalidates the cache.
    365349                wp_update_term( $term_id, 'post_tag', array( 'slug' => 'taco' ) );
    366                 $num_queries = $wpdb->num_queries;
     350                $num_queries = get_num_queries();
    367351
    368352                // This should not hit cache.
    369353                get_term_by( 'name', 'burrito', 'post_tag' );
    370354                $num_queries = $num_queries + 2;
    371                 $this->assertSame( $num_queries, $wpdb->num_queries );
     355                $this->assertSame( $num_queries, get_num_queries() );
    372356        }
    373357
    … …  
    376360         */
    377361        public function test_invalidating_term_caches_should_fail_when_invalidation_is_suspended() {
    378                 global $wpdb;
    379 
    380362                $term_id = self::factory()->term->create(
    381363                        array(
    … …  
    386368
    387369                clean_term_cache( $term_id, 'post_tag' );
    388                 $num_queries  = $wpdb->num_queries;
     370                $num_queries  = get_num_queries();
    389371                $last_changed = wp_cache_get( 'last_changed', 'terms' );
    390372
    … …  
    394376                // Verify the term is cached.
    395377                $term2 = get_term_by( 'name', 'Burrito', 'post_tag' );
    396                 $this->assertSame( $num_queries, $wpdb->num_queries );
     378                $this->assertSame( $num_queries, get_num_queries() );
    397379                $this->assertEquals( $term1, $term2 );
    398380
    … …  
    401383                // Update the tag.
    402384                wp_update_term( $term_id, 'post_tag', array( 'name' => 'Taco' ) );
    403                 $num_queries = $wpdb->num_queries;
     385                $num_queries = get_num_queries();
    404386
    405387                // Verify that the cached term still matches the initial cached term.
    406388                $term3 = get_term_by( 'name', 'Burrito', 'post_tag' );
    407                 $this->assertSame( $num_queries, $wpdb->num_queries );
     389                $this->assertSame( $num_queries, get_num_queries() );
    408390                $this->assertEquals( $term1, $term3 );
    409391
    … …  
    419401         */
    420402        public function test_get_term_by_does_not_prime_term_meta_cache() {
    421                 global $wpdb;
    422 
    423403                $term_id = self::factory()->term->create(
    424404                        array(
    … …  
    430410
    431411                clean_term_cache( $term_id, 'post_tag' );
    432                 $num_queries = $wpdb->num_queries;
     412                $num_queries = get_num_queries();
    433413
    434414                $term        = get_term_by( 'name', 'Burrito', 'post_tag' );
    … …  
    436416                $this->assertInstanceOf( 'WP_Term', $term );
    437417                $this->assertSame( $term_id, $term->term_id );
    438                 $this->assertSame( $num_queries, $wpdb->num_queries );
     418                $this->assertSame( $num_queries, get_num_queries() );
    439419
    440420                $term_meta = get_term_meta( $term_id, 'foo', true );
    441421                $num_queries++;
    442422                $this->assertSame( $term_meta, 'bar' );
    443                 $this->assertSame( $num_queries, $wpdb->num_queries );
     423                $this->assertSame( $num_queries, get_num_queries() );
    444424        }
    445425

  • trunk/tests/phpunit/tests/term/getTerm.php

    r52921 r55745  
    6161
    6262        public function test_passing_term_object_should_skip_database_query_when_filter_property_is_empty() {
    63                 global $wpdb;
    64 
    6563                $term = self::factory()->term->create_and_get( array( 'taxonomy' => 'wptests_tax' ) );
    6664                clean_term_cache( $term->term_id, 'wptests_tax' );
    6765
    68                 $num_queries = $wpdb->num_queries;
     66                $num_queries = get_num_queries();
    6967
    7068                unset( $term->filter );
    7169                $term_a = get_term( $term, 'wptests_tax' );
    7270
    73                 $this->assertSame( $num_queries, $wpdb->num_queries );
     71                $this->assertSame( $num_queries, get_num_queries() );
    7472        }
    7573
    … …  
    8381
    8482        public function test_cache_should_be_populated_by_successful_fetch() {
    85                 global $wpdb;
    86 
    8783                $t = self::factory()->term->create( array( 'taxonomy' => 'wptests_tax' ) );
    8884                clean_term_cache( $t, 'wptests_tax' );
    … …  
    9086                // Prime cache.
    9187                $term_a      = get_term( $t, 'wptests_tax' );
    92                 $num_queries = $wpdb->num_queries;
     88                $num_queries = get_num_queries();
    9389
    9490                // Second call shouldn't require a database query.
    9591                $term_b = get_term( $t, 'wptests_tax' );
    96                 $this->assertSame( $num_queries, $wpdb->num_queries );
     92                $this->assertSame( $num_queries, get_num_queries() );
    9793                $this->assertEquals( $term_a, $term_b );
    9894        }
    … …  
    197193         */
    198194        public function test_shared_term_in_cache_should_be_ignored_when_specifying_a_different_taxonomy() {
    199                 global $wpdb;
    200 
    201195                $terms = $this->generate_shared_terms();
    202196
    203197                // Prime cache for 'wptests_tax'.
    204198                get_term( $terms[0]['term_id'], 'wptests_tax' );
    205                 $num_queries = $wpdb->num_queries;
     199                $num_queries = get_num_queries();
    206200
    207201                // Database should be hit again.
    … …  
    209203                $num_queries++;
    210204
    211                 $this->assertSame( $num_queries, $wpdb->num_queries );
     205                $this->assertSame( $num_queries, get_num_queries() );
    212206                $this->assertInstanceOf( 'WP_Term', $found );
    213207                $this->assertSame( 'wptests_tax_2', $found->taxonomy );

  • trunk/tests/phpunit/tests/term/getTermBy.php

    r54090 r55745  
    112112         */
    113113        public function test_should_prime_term_cache() {
    114                 global $wpdb;
    115 
    116114                register_taxonomy( 'wptests_tax', 'post' );
    117115                $t = self::factory()->term->create(
    … …  
    124122                clean_term_cache( $t, 'wptests_tax' );
    125123
    126                 $num_queries = $wpdb->num_queries;
     124                $num_queries = get_num_queries();
    127125                $found       = get_term_by( 'slug', 'foo', 'wptests_tax' );
    128126                $num_queries = $num_queries + 2;
    … …  
    130128                $this->assertInstanceOf( 'WP_Term', $found );
    131129                $this->assertSame( $t, $found->term_id );
    132                 $this->assertSame( $num_queries, $wpdb->num_queries );
     130                $this->assertSame( $num_queries, get_num_queries() );
    133131
    134132                // Calls to `get_term()` should now hit cache.
    135133                $found2 = get_term( $t );
    136134                $this->assertSame( $t, $found->term_id );
    137                 $this->assertSame( $num_queries, $wpdb->num_queries );
     135                $this->assertSame( $num_queries, get_num_queries() );
    138136        }
    139137

  • trunk/tests/phpunit/tests/term/getTerms.php

    r55671 r55745  
    135135         */
    136136        public function test_get_terms_cache() {
    137                 global $wpdb;
    138 
    139137                $this->set_up_three_posts_and_tags();
    140138
    141                 $num_queries = $wpdb->num_queries;
     139                $num_queries = get_num_queries();
    142140
    143141                // last_changed and num_queries should bump.
    … …  
    146144                $time1 = wp_cache_get( 'last_changed', 'terms' );
    147145                $this->assertNotEmpty( $time1 );
    148                 $this->assertSame( $num_queries + 2, $wpdb->num_queries );
    149 
    150                 $num_queries = $wpdb->num_queries;
     146                $this->assertSame( $num_queries + 2, get_num_queries() );
     147
     148                $num_queries = get_num_queries();
    151149
    152150                // Again. last_changed and num_queries should remain the same.
    … …  
    154152                $this->assertCount( 3, $terms );
    155153                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'terms' ) );
    156                 $this->assertSame( $num_queries, $wpdb->num_queries );
     154                $this->assertSame( $num_queries, get_num_queries() );
    157155        }
    158156
    … …  
    168166                $terms       = get_terms( 'post_tag' );
    169167                $time1       = wp_cache_get( 'last_changed', 'terms' );
    170                 $num_queries = $wpdb->num_queries;
     168                $num_queries = get_num_queries();
    171169
    172170                // num_queries should bump, last_changed should remain the same.
    … …  
    174172                $this->assertCount( 2, $terms );
    175173                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'terms' ) );
    176                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
    177 
    178                 $num_queries = $wpdb->num_queries;
     174                $this->assertSame( $num_queries + 1, get_num_queries() );
     175
     176                $num_queries = get_num_queries();
    179177
    180178                // Again. last_changed and num_queries should remain the same.
    … …  
    182180                $this->assertCount( 2, $terms );
    183181                $this->assertSame( $time1, wp_cache_get( 'last_changed', 'terms' ) );
    184                 $this->assertSame( $num_queries, $wpdb->num_queries );
     182                $this->assertSame( $num_queries, get_num_queries() );
    185183        }
    186184
    … …  
    196194                $terms       = get_terms( 'post_tag' );
    197195                $time1       = wp_cache_get( 'last_changed', 'terms' );
    198                 $num_queries = $wpdb->num_queries;
     196                $num_queries = get_num_queries();
    199197
    200198                // Force last_changed to bump.
    201199                wp_delete_term( $terms[0]->term_id, 'post_tag' );
    202200
    203                 $num_queries = $wpdb->num_queries;
     201                $num_queries = get_num_queries();
    204202                $time2       = wp_cache_get( 'last_changed', 'terms' );
    205203                $this->assertNotEquals( $time1, $time2 );
    … …  
    209207                $this->assertCount( 2, $terms );
    210208                $this->assertSame( $time2, wp_cache_get( 'last_changed', 'terms' ) );
    211                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
    212 
    213                 $num_queries = $wpdb->num_queries;
     209                $this->assertSame( $num_queries + 1, get_num_queries() );
     210
     211                $num_queries = get_num_queries();
    214212
    215213                // Again. last_changed and num_queries should remain the same.
    … …  
    217215                $this->assertCount( 2, $terms );
    218216                $this->assertSame( $time2, wp_cache_get( 'last_changed', 'terms' ) );
    219                 $this->assertSame( $num_queries, $wpdb->num_queries );
     217                $this->assertSame( $num_queries, get_num_queries() );
    220218
    221219                // @todo Repeat with term insert and update.
    … …  
    849847         */
    850848        public function test_child_of_should_skip_query_when_specified_parent_is_not_found_in_hierarchy_cache() {
    851                 global $wpdb;
    852 
    853849                register_taxonomy( 'wptests_tax', 'post', array( 'hierarchical' => true ) );
    854850
    855851                $terms = self::factory()->term->create_many( 3, array( 'taxonomy' => 'wptests_tax' ) );
    856852
    857                 $num_queries = $wpdb->num_queries;
     853                $num_queries = get_num_queries();
    858854
    859855                $found = get_terms(
    … …  
    866862
    867863                $this->assertEmpty( $found );
    868                 $this->assertSame( $num_queries, $wpdb->num_queries );
     864                $this->assertSame( $num_queries, get_num_queries() );
    869865        }
    870866
    … …  
    24742470         */
    24752471        public function test_parent_should_skip_query_when_specified_parent_is_not_found_in_hierarchy_cache() {
    2476                 global $wpdb;
    2477 
    24782472                register_taxonomy( 'wptests_tax', 'post', array( 'hierarchical' => true ) );
    24792473
    24802474                $terms = self::factory()->term->create_many( 3, array( 'taxonomy' => 'wptests_tax' ) );
    24812475
    2482                 $num_queries = $wpdb->num_queries;
     2476                $num_queries = get_num_queries();
    24832477
    24842478                $found = get_terms(
    … …  
    24912485
    24922486                $this->assertEmpty( $found );
    2493                 $this->assertSame( $num_queries, $wpdb->num_queries );
     2487                $this->assertSame( $num_queries, get_num_queries() );
    24942488        }
    24952489
    … …  
    27742768                );
    27752769
    2776                 $num_queries = $wpdb->num_queries;
     2770                $num_queries = get_num_queries();
    27772771
    27782772                foreach ( $terms as $t ) {
    … …  
    27802774                }
    27812775
    2782                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     2776                $this->assertSame( $num_queries + 1, get_num_queries() );
    27832777        }
    27842778
    … …  
    28042798                );
    28052799
    2806                 $num_queries = $wpdb->num_queries;
     2800                $num_queries = get_num_queries();
    28072801
    28082802                foreach ( $terms as $t ) {
    … …  
    28102804                }
    28112805
    2812                 $this->assertSame( $num_queries + 3, $wpdb->num_queries );
     2806                $this->assertSame( $num_queries + 3, get_num_queries() );
    28132807        }
    28142808
    … …  
    29092903                );
    29102904
    2911                 $num_queries = $wpdb->num_queries;
     2905                $num_queries = get_num_queries();
    29122906
    29132907                $found = get_terms(
    … …  
    29192913                );
    29202914
    2921                 $this->assertSame( $num_queries, $wpdb->num_queries );
     2915                $this->assertSame( $num_queries, get_num_queries() );
    29222916
    29232917                $this->assertNotEmpty( $found );
    … …  
    29322926         */
    29332927        public function test_should_prime_individual_term_cache_when_fields_is_all() {
    2934                 global $wpdb;
    2935 
    29362928                register_taxonomy( 'wptests_tax', 'post' );
    29372929                $terms = self::factory()->term->create_many( 2, array( 'taxonomy' => 'wptests_tax' ) );
    … …  
    29452937                );
    29462938
    2947                 $num_queries = $wpdb->num_queries;
     2939                $num_queries = get_num_queries();
    29482940                $term0       = get_term( $terms[0] );
    2949                 $this->assertSame( $num_queries, $wpdb->num_queries );
     2941                $this->assertSame( $num_queries, get_num_queries() );
    29502942
    29512943        }

  • trunk/tests/phpunit/tests/term/getTheTerms.php

    r52010 r55745  
    198198         */
    199199        public function test_uncached_terms_should_be_primed_with_a_single_query() {
    200                 global $wpdb;
    201 
    202200                register_taxonomy( 'wptests_tax', 'post' );
    203201
    … …  
    211209                clean_term_cache( array( $terms[0], $terms[1] ), 'wptests_tax', false );
    212210
    213                 $num_queries = $wpdb->num_queries;
     211                $num_queries = get_num_queries();
    214212                $found       = get_the_terms( self::$post_ids[0], 'wptests_tax' );
    215213
    … …  
    217215
    218216                $num_queries++;
    219                 $this->assertSame( $num_queries, $wpdb->num_queries );
     217                $this->assertSame( $num_queries, get_num_queries() );
    220218
    221219        }

  • trunk/tests/phpunit/tests/term/isObjectInTerm.php

    r55365 r55745  
    136136         */
    137137        public function test_should_populate_and_hit_relationships_cache() {
    138                 global $wpdb;
    139 
    140138                register_taxonomy( 'wptests_tax', 'post' );
    141139                $terms = self::factory()->term->create_many( 2, array( 'taxonomy' => 'wptests_tax' ) );
    … …  
    144142                wp_set_object_terms( $o, $terms[0], 'wptests_tax' );
    145143
    146                 $num_queries = $wpdb->num_queries;
     144                $num_queries = get_num_queries();
    147145                $this->assertTrue( is_object_in_term( $o, 'wptests_tax', $terms[0] ) );
    148146                $num_queries = $num_queries + 2;
    149                 $this->assertSame( $num_queries, $wpdb->num_queries );
     147                $this->assertSame( $num_queries, get_num_queries() );
    150148
    151149                $this->assertFalse( is_object_in_term( $o, 'wptests_tax', $terms[1] ) );
    152                 $this->assertSame( $num_queries, $wpdb->num_queries );
     150                $this->assertSame( $num_queries, get_num_queries() );
    153151        }
    154152
    … …  
    157155         */
    158156        public function test_should_not_be_fooled_by_a_stale_relationship_cache() {
    159                 global $wpdb;
    160 
    161157                register_taxonomy( 'wptests_tax', 'post' );
    162158                $terms = self::factory()->term->create_many( 2, array( 'taxonomy' => 'wptests_tax' ) );
    … …  
    165161                wp_set_object_terms( $o, $terms[0], 'wptests_tax' );
    166162
    167                 $num_queries = $wpdb->num_queries;
     163                $num_queries = get_num_queries();
    168164                $this->assertTrue( is_object_in_term( $o, 'wptests_tax', $terms[0] ) );
    169165                $num_queries = $num_queries + 2;
    170                 $this->assertSame( $num_queries, $wpdb->num_queries );
     166                $this->assertSame( $num_queries, get_num_queries() );
    171167
    172168                wp_set_object_terms( $o, $terms[1], 'wptests_tax' );
    173169
    174                 $num_queries = $wpdb->num_queries;
     170                $num_queries = get_num_queries();
    175171                $this->assertTrue( is_object_in_term( $o, 'wptests_tax', $terms[1] ) );
    176172                $num_queries = $num_queries + 2;
    177                 $this->assertSame( $num_queries, $wpdb->num_queries );
     173                $this->assertSame( $num_queries, get_num_queries() );
    178174        }
    179175

  • trunk/tests/phpunit/tests/term/meta.php

    r55671 r55745  
    115115
    116116        public function test_term_meta_should_be_lazy_loaded_for_all_terms_in_wp_query_loop() {
    117                 global $wpdb;
    118 
    119117                $p = self::factory()->post->create( array( 'post_status' => 'publish' ) );
    120118
    … …  
    140138
    141139                                // First request will hit the database.
    142                                 $num_queries = $wpdb->num_queries;
     140                                $num_queries = get_num_queries();
    143141                                $this->assertSame( 'bar', get_term_meta( $terms[0], 'foo', true ) );
    144142                                $num_queries++;
    145                                 $this->assertSame( $num_queries, $wpdb->num_queries );
     143                                $this->assertSame( $num_queries, get_num_queries() );
    146144
    147145                                // Second and third requests should be in cache.
    148146                                $this->assertSame( 'bar', get_term_meta( $terms[1], 'foo', true ) );
    149147                                $this->assertSame( 'bar', get_term_meta( $terms[2], 'foo', true ) );
    150                                 $this->assertSame( $num_queries, $wpdb->num_queries );
     148                                $this->assertSame( $num_queries, get_num_queries() );
    151149
    152150                                // Querying a term not primed should result in a hit.
    153151                                $num_queries++;
    154152                                $this->assertSame( 'bar', get_term_meta( $orphan_term, 'foo', true ) );
    155                                 $this->assertSame( $num_queries, $wpdb->num_queries );
     153                                $this->assertSame( $num_queries, get_num_queries() );
    156154                        }
    157155                }
    … …  
    187185         */
    188186        public function test_lazy_load_term_meta_false() {
    189                 global $wpdb;
    190 
    191187                $p = self::factory()->post->create( array( 'post_status' => 'publish' ) );
    192188
    … …  
    211207
    212208                                // Requests will hit the database.
    213                                 $num_queries = $wpdb->num_queries;
     209                                $num_queries = get_num_queries();
    214210                                $this->assertSame( 'bar', get_term_meta( $terms[0], 'foo', true ) );
    215211                                $num_queries++;
    216                                 $this->assertSame( $num_queries, $wpdb->num_queries );
     212                                $this->assertSame( $num_queries, get_num_queries() );
    217213
    218214                                $this->assertSame( 'bar', get_term_meta( $terms[1], 'foo', true ) );
    219215                                $num_queries++;
    220                                 $this->assertSame( $num_queries, $wpdb->num_queries );
     216                                $this->assertSame( $num_queries, get_num_queries() );
    221217                        }
    222218                }

  • trunk/tests/phpunit/tests/term/query.php

    r55671 r55745  
    457457         */
    458458        public function test_count_query_should_be_cached() {
    459                 global $wpdb;
    460 
    461459                register_taxonomy( 'wptests_tax_1', 'post' );
    462460
    … …  
    473471                $this->assertEquals( 2, $count );
    474472
    475                 $num_queries = $wpdb->num_queries;
     473                $num_queries = get_num_queries();
    476474
    477475                $query = new WP_Term_Query(
    … …  
    484482                $count = $query->get_terms();
    485483                $this->assertEquals( 2, $count );
    486                 $this->assertSame( $num_queries, $wpdb->num_queries );
     484                $this->assertSame( $num_queries, get_num_queries() );
    487485        }
    488486
    … …  
    804802         */
    805803        public function test_terms_pre_query_filter_should_bypass_database_query() {
    806                 global $wpdb;
    807 
    808804                add_filter( 'terms_pre_query', array( __CLASS__, 'filter_terms_pre_query' ), 10, 2 );
    809805
    810                 $num_queries = $wpdb->num_queries;
     806                $num_queries = get_num_queries();
    811807
    812808                $q       = new WP_Term_Query();
    … …  
    820816
    821817                // Make sure no queries were executed.
    822                 $this->assertSame( $num_queries, $wpdb->num_queries );
     818                $this->assertSame( $num_queries, get_num_queries() );
    823819
    824820                // We manually inserted a non-existing term and overrode the results with it.

  • trunk/tests/phpunit/tests/term/termExists.php

    r52921 r55745  
    321321         */
    322322        public function test_term_exists_caching() {
    323                 global $wpdb;
    324323                register_taxonomy( 'wptests_tax', 'post' );
    325324
    … …  
    332331                );
    333332                $this->assertEquals( $t, term_exists( $slug ) );
    334                 $num_queries = $wpdb->num_queries;
     333                $num_queries = get_num_queries();
    335334                $this->assertEquals( $t, term_exists( $slug ) );
    336                 $this->assertSame( $num_queries, $wpdb->num_queries );
     335                $this->assertSame( $num_queries, get_num_queries() );
    337336
    338337                $this->assertTrue( wp_delete_term( $t, 'wptests_tax' ) );
    339                 $num_queries = $wpdb->num_queries;
     338                $num_queries = get_num_queries();
    340339                $this->assertNull( term_exists( $slug ) );
    341                 $this->assertSame( $num_queries + 2, $wpdb->num_queries );
     340                $this->assertSame( $num_queries + 2, get_num_queries() );
    342341
    343342                // Clean up.
    … …  
    350349         */
    351350        public function test_term_exists_caching_suspend_cache_invalidation() {
    352                 global $wpdb;
    353351                register_taxonomy( 'wptests_tax', 'post' );
    354352
    … …  
    363361
    364362                $this->assertEquals( $t, term_exists( $slug ) );
    365                 $num_queries = $wpdb->num_queries;
     363                $num_queries = get_num_queries();
    366364                $this->assertEquals( $t, term_exists( $slug ) );
    367                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     365                $this->assertSame( $num_queries + 1, get_num_queries() );
    368366                wp_suspend_cache_invalidation( false );
    369367

  • trunk/tests/phpunit/tests/term/wpGetObjectTerms.php

    r55671 r55745  
    617617         */
    618618        public function test_termmeta_cache_should_be_lazy_loaded_by_default() {
    619                 global $wpdb;
    620 
    621619                register_taxonomy( 'wptests_tax', 'post' );
    622620                $terms = self::factory()->term->create_many( 3, array( 'taxonomy' => 'wptests_tax' ) );
    … …  
    630628                $found = wp_get_object_terms( $p, 'wptests_tax' );
    631629
    632                 $num_queries = $wpdb->num_queries;
     630                $num_queries = get_num_queries();
    633631
    634632                foreach ( $terms as $t ) {
    … …  
    636634                }
    637635
    638                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     636                $this->assertSame( $num_queries + 1, get_num_queries() );
    639637        }
    640638
    … …  
    643641         */
    644642        public function test_termmeta_cache_should_not_be_primed_when_update_term_meta_cache_is_false() {
    645                 global $wpdb;
    646 
    647643                register_taxonomy( 'wptests_tax', 'post' );
    648644                $terms = self::factory()->term->create_many( 3, array( 'taxonomy' => 'wptests_tax' ) );
    … …  
    662658                );
    663659
    664                 $num_queries = $wpdb->num_queries;
     660                $num_queries = get_num_queries();
    665661
    666662                foreach ( $terms as $t ) {
    … …  
    668664                }
    669665
    670                 $this->assertSame( $num_queries + 3, $wpdb->num_queries );
     666                $this->assertSame( $num_queries + 3, get_num_queries() );
    671667        }
    672668
    … …  
    675671         */
    676672        public function test_termmeta_cache_should_be_primed_when_fields_is_all_with_object_id() {
    677                 global $wpdb;
    678 
    679673                register_taxonomy( 'wptests_tax', 'post' );
    680674                $terms = self::factory()->term->create_many( 3, array( 'taxonomy' => 'wptests_tax' ) );
    … …  
    695689                );
    696690
    697                 $num_queries = $wpdb->num_queries;
     691                $num_queries = get_num_queries();
    698692
    699693                foreach ( $terms as $t ) {
    … …  
    701695                }
    702696
    703                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     697                $this->assertSame( $num_queries + 1, get_num_queries() );
    704698        }
    705699
    … …  
    708702         */
    709703        public function test_termmeta_cache_should_be_primed_when_fields_is_ids() {
    710                 global $wpdb;
    711 
    712704                register_taxonomy( 'wptests_tax', 'post' );
    713705                $terms = self::factory()->term->create_many( 3, array( 'taxonomy' => 'wptests_tax' ) );
    … …  
    728720                );
    729721
    730                 $num_queries = $wpdb->num_queries;
     722                $num_queries = get_num_queries();
    731723
    732724                foreach ( $terms as $t ) {
    … …  
    734726                }
    735727
    736                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     728                $this->assertSame( $num_queries + 1, get_num_queries() );
    737729        }
    738730
    … …  
    817809         */
    818810        public function test_should_prime_cache_for_found_terms() {
    819                 global $wpdb;
    820 
    821811                register_taxonomy( 'wptests_tax', 'post' );
    822812                $p = self::factory()->post->create();
    … …  
    832822                );
    833823
    834                 $num_queries = $wpdb->num_queries;
     824                $num_queries = get_num_queries();
    835825                $term        = get_term( $t );
    836                 $this->assertSame( $num_queries, $wpdb->num_queries );
     826                $this->assertSame( $num_queries, get_num_queries() );
    837827        }
    838828
    … …  
    866856         */
    867857        public function test_term_cache_should_be_primed_for_all_taxonomies() {
    868                 global $wpdb;
    869 
    870858                register_taxonomy( 'wptests_tax1', 'post' );
    871859                register_taxonomy( 'wptests_tax2', 'post' );
    … …  
    889877                $this->assertSameSets( array( $t1, $t2 ), wp_list_pluck( $found, 'term_id' ) );
    890878
    891                 $num_queries = $wpdb->num_queries;
     879                $num_queries = get_num_queries();
    892880                $term1       = get_term( $t1 );
    893881                $term2       = get_term( $t2 );
    894                 $this->assertSame( $num_queries, $wpdb->num_queries );
     882                $this->assertSame( $num_queries, get_num_queries() );
    895883        }
    896884

  • trunk/tests/phpunit/tests/user/query.php

    r55562 r55745  
    17211721         */
    17221722        public function test_users_pre_query_filter_should_bypass_database_query() {
    1723                 global $wpdb;
    1724 
    17251723                add_filter( 'users_pre_query', array( __CLASS__, 'filter_users_pre_query' ), 10, 2 );
    17261724
    1727                 $num_queries = $wpdb->num_queries;
     1725                $num_queries = get_num_queries();
    17281726                $q           = new WP_User_Query(
    17291727                        array(
    … …  
    17351733
    17361734                // Make sure no queries were executed.
    1737                 $this->assertSame( $num_queries, $wpdb->num_queries );
     1735                $this->assertSame( $num_queries, get_num_queries() );
    17381736
    17391737                // We manually inserted a non-existing user and overrode the results with it.
Note: See TracChangeset for help on using the changeset viewer.