WordPress.org
Get WordPress

Make WordPress Core


Ignore:
Timestamp:
09/30/2014 09:17:38 PM (10 years ago)
Author:
boonebgorges
Message:

Improve unit tests related to WP_Meta_Query.

  • More complete test coverage for publicly available methods of WP_Meta_Query.
  • Move tests that rely on WP_Query (via the meta_query parameter) to tests/post/query.php.
  • Better coverage for basic use cases of 'meta_query', including all values of 'compare' and default values of 'key', 'value', and 'compare'.
  • Improve performance for tests that run WP_Query, by retrieving only post IDs and not prefetching postmeta and post terms.
  • Add 'public' visibility keywords to test methods.
  • Whitespace cleanup.

Fixes #29560

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r29760 r29799  
    11<?php
    22
    3 /**
    4  * @group meta
    5  */
    63class Tests_Post_Query extends WP_UnitTestCase {
    74    function setUp() {
    … …  
    96    }
    107
    11     function test_meta_key_or_query() {
     8    /**
     9     * @group meta
     10     */
     11    public function test_meta_query_no_key() {
     12        $p1 = $this->factory->post->create();
     13        $p2 = $this->factory->post->create();
     14        $p3 = $this->factory->post->create();
     15
     16        add_post_meta( $p1, 'foo', 'bar' );
     17        add_post_meta( $p2, 'oof', 'bar' );
     18        add_post_meta( $p3, 'oof', 'baz' );
     19
     20        $query = new WP_Query( array(
     21            'update_post_meta_cache' => false,
     22            'update_post_term_cache' => false,
     23            'fields' => 'ids',
     24            'meta_query' => array(
     25                array(
     26                    'value' => 'bar',
     27                ),
     28            ),
     29        ) );
     30
     31        $expected = array( $p1, $p2 );
     32        $this->assertEqualSets( $expected, $query->posts );
     33    }
     34
     35    /**
     36     * @group meta
     37     */
     38    public function test_meta_query_no_value() {
     39        $p1 = $this->factory->post->create();
     40        $p2 = $this->factory->post->create();
     41        $p3 = $this->factory->post->create();
     42
     43        add_post_meta( $p1, 'foo', 'bar' );
     44        add_post_meta( $p2, 'oof', 'bar' );
     45        add_post_meta( $p3, 'oof', 'baz' );
     46
     47        $query = new WP_Query( array(
     48            'update_post_meta_cache' => false,
     49            'update_post_term_cache' => false,
     50            'fields' => 'ids',
     51            'meta_query' => array(
     52                array(
     53                    'key' => 'oof',
     54                ),
     55            ),
     56        ) );
     57
     58        $expected = array( $p2, $p3 );
     59        $this->assertEqualSets( $expected, $query->posts );
     60    }
     61
     62    /**
     63     * @group meta
     64     */
     65    public function test_meta_query_single_query_compare_default() {
     66        $p1 = $this->factory->post->create();
     67        $p2 = $this->factory->post->create();
     68
     69        add_post_meta( $p1, 'foo', 'bar' );
     70
     71        $query = new WP_Query( array(
     72            'update_post_meta_cache' => false,
     73            'update_post_term_cache' => false,
     74            'fields' => 'ids',
     75            'meta_query' => array(
     76                array(
     77                    'key' => 'foo',
     78                    'value' => 'bar',
     79                ),
     80            ),
     81        ) );
     82
     83        $expected = array( $p1 );
     84        $this->assertEqualSets( $expected, $query->posts );
     85    }
     86
     87    /**
     88     * @group meta
     89     */
     90    public function test_meta_query_single_query_compare_equals() {
     91        $p1 = $this->factory->post->create();
     92        $p2 = $this->factory->post->create();
     93
     94        add_post_meta( $p1, 'foo', 'bar' );
     95
     96        $query = new WP_Query( array(
     97            'update_post_meta_cache' => false,
     98            'update_post_term_cache' => false,
     99            'fields' => 'ids',
     100            'meta_query' => array(
     101                array(
     102                    'key' => 'foo',
     103                    'value' => 'bar',
     104                    'compare' => '=',
     105                ),
     106            ),
     107        ) );
     108
     109        $expected = array( $p1 );
     110        $this->assertEqualSets( $expected, $query->posts );
     111    }
     112
     113    /**
     114     * @group meta
     115     */
     116    public function test_meta_query_single_query_compare_not_equals() {
     117        $p1 = $this->factory->post->create();
     118        $p2 = $this->factory->post->create();
     119        $p3 = $this->factory->post->create();
     120
     121        add_post_meta( $p1, 'foo', 'bar' );
     122        add_post_meta( $p2, 'foo', 'baz' );
     123
     124        $query = new WP_Query( array(
     125            'update_post_meta_cache' => false,
     126            'update_post_term_cache' => false,
     127            'fields' => 'ids',
     128            'meta_query' => array(
     129                array(
     130                    'key' => 'foo',
     131                    'value' => 'bar',
     132                    'compare' => '!=',
     133                ),
     134            ),
     135        ) );
     136
     137        $expected = array( $p2 );
     138        $this->assertEqualSets( $expected, $query->posts );
     139    }
     140
     141    /**
     142     * @group meta
     143     */
     144    public function test_meta_query_single_query_compare_arithmetic_comparisons() {
     145        $p1 = $this->factory->post->create();
     146        $p2 = $this->factory->post->create();
     147        $p3 = $this->factory->post->create();
     148
     149        add_post_meta( $p1, 'foo', '1' );
     150        add_post_meta( $p2, 'foo', '2' );
     151        add_post_meta( $p3, 'foo', '3' );
     152
     153        // <
     154        $query = new WP_Query( array(
     155            'update_post_meta_cache' => false,
     156            'update_post_term_cache' => false,
     157            'fields' => 'ids',
     158            'meta_query' => array(
     159                array(
     160                    'key' => 'foo',
     161                    'value' => 2,
     162                    'compare' => '<',
     163                ),
     164            ),
     165        ) );
     166
     167        $expected = array( $p1 );
     168        $this->assertEqualSets( $expected, $query->posts );
     169
     170        // <=
     171        $query = new WP_Query( array(
     172            'update_post_meta_cache' => false,
     173            'update_post_term_cache' => false,
     174            'fields' => 'ids',
     175            'meta_query' => array(
     176                array(
     177                    'key' => 'foo',
     178                    'value' => 2,
     179                    'compare' => '<=',
     180                ),
     181            ),
     182        ) );
     183
     184        $expected = array( $p1, $p2 );
     185        $this->assertEqualSets( $expected, $query->posts );
     186
     187        // >=
     188        $query = new WP_Query( array(
     189            'update_post_meta_cache' => false,
     190            'update_post_term_cache' => false,
     191            'fields' => 'ids',
     192            'meta_query' => array(
     193                array(
     194                    'key' => 'foo',
     195                    'value' => 2,
     196                    'compare' => '>=',
     197                ),
     198            ),
     199        ) );
     200
     201        $expected = array( $p2, $p3 );
     202        $this->assertEqualSets( $expected, $query->posts );
     203
     204        // >
     205        $query = new WP_Query( array(
     206            'update_post_meta_cache' => false,
     207            'update_post_term_cache' => false,
     208            'fields' => 'ids',
     209            'meta_query' => array(
     210                array(
     211                    'key' => 'foo',
     212                    'value' => 2,
     213                    'compare' => '>',
     214                ),
     215            ),
     216        ) );
     217
     218        $expected = array( $p3 );
     219        $this->assertEqualSets( $expected, $query->posts );
     220    }
     221
     222    /**
     223     * @group meta
     224     */
     225    public function test_meta_query_single_query_compare_like() {
     226        $p1 = $this->factory->post->create();
     227        $p2 = $this->factory->post->create();
     228
     229        add_post_meta( $p1, 'foo', 'bar' );
     230
     231        $query = new WP_Query( array(
     232            'update_post_meta_cache' => false,
     233            'update_post_term_cache' => false,
     234            'fields' => 'ids',
     235            'meta_query' => array(
     236                array(
     237                    'key' => 'foo',
     238                    'value' => 'ba',
     239                    'compare' => 'LIKE',
     240                ),
     241            ),
     242        ) );
     243
     244        $expected = array( $p1 );
     245        $this->assertEqualSets( $expected, $query->posts );
     246    }
     247
     248    /**
     249     * @group meta
     250     */
     251    public function test_meta_query_single_query_compare_not_like() {
     252        $p1 = $this->factory->post->create();
     253        $p2 = $this->factory->post->create();
     254        $p3 = $this->factory->post->create();
     255
     256        add_post_meta( $p1, 'foo', 'bar' );
     257        add_post_meta( $p2, 'foo', 'rab' );
     258
     259        $query = new WP_Query( array(
     260            'update_post_meta_cache' => false,
     261            'update_post_term_cache' => false,
     262            'fields' => 'ids',
     263            'meta_query' => array(
     264                array(
     265                    'key' => 'foo',
     266                    'value' => 'ba',
     267                    'compare' => 'NOT LIKE',
     268                ),
     269            ),
     270        ) );
     271
     272        $expected = array( $p2 );
     273        $this->assertEqualSets( $expected, $query->posts );
     274    }
     275
     276    /**
     277     * @group meta
     278     */
     279    public function test_meta_query_single_query_compare_between_not_between() {
     280        $p1 = $this->factory->post->create();
     281        $p2 = $this->factory->post->create();
     282        $p3 = $this->factory->post->create();
     283
     284        add_post_meta( $p1, 'foo', '1' );
     285        add_post_meta( $p2, 'foo', '10' );
     286        add_post_meta( $p3, 'foo', '100' );
     287
     288        $query = new WP_Query( array(
     289            'update_post_meta_cache' => false,
     290            'update_post_term_cache' => false,
     291            'fields' => 'ids',
     292            'meta_query' => array(
     293                array(
     294                    'key' => 'foo',
     295                    'value' => array( 9, 12 ),
     296                    'compare' => 'BETWEEN',
     297                    'type' => 'NUMERIC',
     298                ),
     299            ),
     300        ) );
     301
     302        $expected = array( $p2 );
     303        $this->assertEqualSets( $expected, $query->posts );
     304
     305        $query = new WP_Query( array(
     306            'update_post_meta_cache' => false,
     307            'update_post_term_cache' => false,
     308            'fields' => 'ids',
     309            'meta_query' => array(
     310                array(
     311                    'key' => 'foo',
     312                    'value' => array( 9, 12 ),
     313                    'compare' => 'NOT BETWEEN',
     314                    'type' => 'NUMERIC',
     315                ),
     316            ),
     317        ) );
     318
     319        $expected = array( $p1, $p3 );
     320        $this->assertEqualSets( $expected, $query->posts );
     321    }
     322
     323    /**
     324     * @group meta
     325     */
     326    public function test_meta_query_single_query_compare_regexp_rlike() {
     327        $p1 = $this->factory->post->create();
     328        $p2 = $this->factory->post->create();
     329
     330        add_post_meta( $p1, 'foo', 'bar' );
     331        add_post_meta( $p2, 'foo', 'baz' );
     332
     333        $query = new WP_Query( array(
     334            'update_post_meta_cache' => false,
     335            'update_post_term_cache' => false,
     336            'fields' => 'ids',
     337            'meta_query' => array(
     338                array(
     339                    'key' => 'foo',
     340                    'value' => 'z$',
     341                    'compare' => 'REGEXP',
     342                ),
     343            ),
     344        ) );
     345
     346        $expected = array( $p2 );
     347        $this->assertEqualSets( $expected, $query->posts );
     348
     349        // RLIKE is a synonym for REGEXP.
     350        $query = new WP_Query( array(
     351            'update_post_meta_cache' => false,
     352            'update_post_term_cache' => false,
     353            'fields' => 'ids',
     354            'meta_query' => array(
     355                array(
     356                    'key' => 'foo',
     357                    'value' => 'z$',
     358                    'compare' => 'RLIKE',
     359                ),
     360            ),
     361        ) );
     362
     363        $expected = array( $p2 );
     364        $this->assertEqualSets( $expected, $query->posts );
     365    }
     366
     367    /**
     368     * @group meta
     369     */
     370    public function test_meta_query_single_query_compare_not_regexp() {
     371        $p1 = $this->factory->post->create();
     372        $p2 = $this->factory->post->create();
     373
     374        add_post_meta( $p1, 'foo', 'bar' );
     375        add_post_meta( $p2, 'foo', 'baz' );
     376
     377        $query = new WP_Query( array(
     378            'update_post_meta_cache' => false,
     379            'update_post_term_cache' => false,
     380            'fields' => 'ids',
     381            'meta_query' => array(
     382                array(
     383                    'key' => 'foo',
     384                    'value' => 'z$',
     385                    'compare' => 'NOT REGEXP',
     386                ),
     387            ),
     388        ) );
     389
     390        $expected = array( $p1 );
     391        $this->assertEqualSets( $expected, $query->posts );
     392    }
     393
     394    /**
     395     * @group meta
     396     */
     397    public function test_meta_query_relation_default() {
     398        $p1 = $this->factory->post->create();
     399        $p2 = $this->factory->post->create();
     400        $p3 = $this->factory->post->create();
     401
     402        add_post_meta( $p1, 'foo', 'foo value 1' );
     403        add_post_meta( $p1, 'bar', 'bar value 1' );
     404        add_post_meta( $p2, 'foo', 'foo value 1' );
     405        add_post_meta( $p2, 'bar', 'bar value 2' );
     406
     407        $query = new WP_Query( array(
     408            'update_post_meta_cache' => false,
     409            'update_post_term_cache' => false,
     410            'fields' => 'ids',
     411            'meta_query' => array(
     412                array(
     413                    'key' => 'foo',
     414                    'value' => 'foo value 1',
     415                ),
     416                array(
     417                    'key' => 'bar',
     418                    'value' => 'bar value 1',
     419                ),
     420            ),
     421        ) );
     422
     423        $expected = array( $p1 );
     424        $this->assertEquals( $expected, $query->posts );
     425    }
     426
     427    /**
     428     * @group meta
     429     */
     430    public function test_meta_query_relation_or() {
    12431        $post_id = $this->factory->post->create();
    13432        add_post_meta( $post_id, 'foo', rand_str() );
    … …  
    25444
    26445        $query = new WP_Query( array(
     446            'update_post_meta_cache' => false,
     447            'update_post_term_cache' => false,
     448            'fields' => 'ids',
    27449            'meta_query' => array(
    28450                array(
    … …  
    43465        ) );
    44466
    45         $posts = $query->get_posts();
    46         $this->assertEquals( 4, count( $posts ) );
    47         foreach ( $posts as $post ) {
    48             $this->assertInstanceOf( 'WP_Post', $post );
    49             $this->assertEquals( 'raw', $post->filter );
    50         }
    51 
    52         $post_ids = wp_list_pluck( $posts, 'ID' );
    53         $this->assertEqualSets( array( $post_id, $post_id2, $post_id3, $post_id4 ), $post_ids );
    54     }
    55 
    56     function test_meta_key_and_query() {
     467        $expected = array( $post_id, $post_id2, $post_id3, $post_id4 );
     468        $this->assertEqualSets( $expected, $query->posts );
     469    }
     470
     471    /**
     472     * @group meta
     473     */
     474    public function test_meta_query_relation_and() {
    57475        $post_id = $this->factory->post->create();
    58476        add_post_meta( $post_id, 'foo', rand_str() );
    … …  
    93511                'relation' => 'AND',
    94512            ),
    95         ) );
    96 
    97         $posts = $query->get_posts();
    98         $this->assertEquals( 1, count( $posts ) );
    99         foreach ( $posts as $post ) {
    100             $this->assertInstanceOf( 'WP_Post', $post );
    101             $this->assertEquals( 'raw', $post->filter );
    102         }
    103 
    104         $post_ids = wp_list_pluck( $posts, 'ID' );
    105         $this->assertEquals( array( $post_id7 ), $post_ids );
     513            'update_post_meta_cache' => false,
     514            'update_post_term_cache' => false,
     515            'fields' => 'ids',
     516        ) );
     517
     518        $expected = array( $post_id7 );
     519        $this->assertEqualSets( $expected, $query->posts );
    106520
    107521        $query = new WP_Query( array(
    … …  
    115529                'relation' => 'AND',
    116530            ),
    117         ) );
    118 
    119         $posts = $query->get_posts();
    120         $this->assertEquals( 3, count( $posts ) );
    121         foreach ( $posts as $post ) {
    122             $this->assertInstanceOf( 'WP_Post', $post );
    123             $this->assertEquals( 'raw', $post->filter );
    124         }
    125 
    126         $post_ids = wp_list_pluck( $posts, 'ID' );
    127         $this->assertEqualSets( array( $post_id2, $post_id6, $post_id7 ), $post_ids );
     531            'update_post_meta_cache' => false,
     532            'update_post_term_cache' => false,
     533            'fields' => 'ids',
     534        ) );
     535
     536        $expected = array( $post_id2, $post_id6, $post_id7 );
     537        $this->assertEqualSets( $expected, $query->posts );
    128538    }
    129539
    130540    /**
    131541     * @ticket 18158
    132      */
    133     function test_meta_key_not_exists() {
     542     * @group meta
     543     */
     544    public function test_meta_query_compare_not_exists() {
    134545        $post_id = $this->factory->post->create();
    135546        add_post_meta( $post_id, 'foo', rand_str() );
    … …  
    145556        $query = new WP_Query( array(
    146557            'meta_query' => array(
    147             array(
    148                 'key' => 'foo',
    149                 'compare' => 'NOT EXISTS',
    150             ),
    151             ),
    152         ) );
    153 
    154         $posts = $query->get_posts();
    155         $this->assertEquals( 3, count( $posts ) );
    156         foreach ( $posts as $post ) {
    157             $this->assertInstanceOf( 'WP_Post', $post );
    158             $this->assertEquals( 'raw', $post->filter );
    159         }
    160 
    161         $query = new WP_Query( array(
    162             'meta_query' => array(
    163             array(
    164                 'key' => 'foo',
    165                 'compare' => 'NOT EXISTS',
    166             ),
    167                 array(
    168                 'key' => 'bar',
    169                 'compare' => 'NOT EXISTS',
    170             ),
    171             ),
    172         ) );
    173 
    174         $posts = $query->get_posts();
    175         $this->assertEquals( 1, count( $posts ) );
    176         foreach ( $posts as $post ) {
    177             $this->assertInstanceOf( 'WP_Post', $post );
    178             $this->assertEquals( 'raw', $post->filter );
    179         }
    180 
    181         $query = new WP_Query( array(
    182             'meta_query' => array(
    183             array(
    184                 'key' => 'foo',
    185                 'compare' => 'NOT EXISTS',
    186             ),
    187                 array(
    188                 'key' => 'bar',
    189                 'compare' => 'NOT EXISTS',
    190             ),
    191                 array(
    192                 'key' => 'baz',
    193                 'compare' => 'NOT EXISTS',
    194             ),
    195             )
    196         ) );
    197 
    198         $posts = $query->get_posts();
    199         $this->assertEquals( 0, count( $posts ) );
     558                array(
     559                    'key' => 'foo',
     560                    'compare' => 'NOT EXISTS',
     561                ),
     562            ),
     563            'update_post_meta_cache' => false,
     564            'update_post_term_cache' => false,
     565            'fields' => 'ids',
     566        ) );
     567
     568        $expected = array( $post_id2, $post_id3, $post_id4 );
     569        $this->assertEqualSets( $expected, $query->posts );
     570
     571        $query = new WP_Query( array(
     572            'meta_query' => array(
     573                array(
     574                    'key' => 'foo',
     575                    'compare' => 'NOT EXISTS',
     576                ),
     577                array(
     578                    'key' => 'bar',
     579                    'compare' => 'NOT EXISTS',
     580                ),
     581            ),
     582            'update_post_meta_cache' => false,
     583            'update_post_term_cache' => false,
     584            'fields' => 'ids',
     585        ) );
     586
     587        $expected = array( $post_id4 );
     588        $this->assertEquals( $expected, $query->posts );
     589
     590        $query = new WP_Query( array(
     591            'meta_query' => array(
     592                array(
     593                    'key' => 'foo',
     594                    'compare' => 'NOT EXISTS',
     595                ),
     596                array(
     597                    'key' => 'bar',
     598                    'compare' => 'NOT EXISTS',
     599                ),
     600                array(
     601                    'key' => 'baz',
     602                    'compare' => 'NOT EXISTS',
     603                ),
     604            ),
     605            'update_post_meta_cache' => false,
     606            'update_post_term_cache' => false,
     607            'fields' => 'ids',
     608        ) );
     609
     610        $this->assertEquals( 0, count( $query->posts ) );
    200611    }
    201612
    202613    /**
    203614     * @ticket 23033
    204      */
    205     function test_meta_query_decimal_results() {
     615     * @group meta
     616     */
     617    public function test_meta_query_decimal_results() {
    206618        $post_1 = $this->factory->post->create();
    207619        $post_2 = $this->factory->post->create();
    … …  
    216628        $query = new WP_Query( array(
    217629            'meta_query' => array(
    218                     array(
    219                         'key' => 'decimal_value',
    220                         'value' => '.300',
    221                         'compare' => '=',
    222                         'type' => 'DECIMAL(10,2)'
    223                     )
    224                 ),
    225         ) );
    226         $this->assertEqualSets( array( $post_3 ), wp_list_pluck( $query->posts, 'ID' ) );
    227 
    228         $query = new WP_Query( array(
    229             'meta_query' => array(
    230                     array(
    231                         'key' => 'decimal_value',
    232                         'value' => '0.35',
    233                         'compare' => '>',
    234                         'type' => 'DECIMAL(10,2)'
    235                     )
    236                 ),
    237         ) );
    238         $this->assertEqualSets( array( $post_4 ), wp_list_pluck( $query->posts, 'ID' ) );
    239 
    240         $query = new WP_Query( array(
    241             'meta_query' => array(
    242                     array(
    243                         'key' => 'decimal_value',
    244                         'value' => '0.3',
    245                         'compare' => '>=',
    246                         'type' => 'DECIMAL(10,2)'
    247                     )
    248                 ),
    249         ) );
    250         $this->assertEqualSets( array( $post_3, $post_4 ), wp_list_pluck( $query->posts, 'ID' ) );
    251 
    252         $query = new WP_Query( array(
    253             'meta_query' => array(
    254                     array(
    255                         'key' => 'decimal_value',
    256                         'value' => '0',
    257                         'compare' => '<',
    258                         'type' => 'DECIMAL(10,2)'
    259                     )
    260                 ),
    261         ) );
    262         $this->assertEqualSets( array( $post_1 ), wp_list_pluck( $query->posts, 'ID' ) );
    263 
    264         $query = new WP_Query( array(
    265             'meta_query' => array(
    266                     array(
    267                         'key' => 'decimal_value',
    268                         'value' => '0.3',
    269                         'compare' => '<=',
    270                         'type' => 'DECIMAL(10,2)'
    271                     )
    272                 ),
    273 
    274         ) );
    275         $this->assertEqualSets( array( $post_1, $post_2, $post_3 ), wp_list_pluck( $query->posts, 'ID' ) );
    276 
    277         $query = new WP_Query( array(
    278             'meta_query' => array(
    279                     array(
    280                         'key' => 'decimal_value',
    281                         'value' => array( 0.23409845, .31 ),
    282                         'compare' => 'BETWEEN',
    283                         'type' => 'DECIMAL(10, 10)'
    284                     )
    285                 ),
    286         ) );
    287         $this->assertEqualSets( array( $post_3 ), wp_list_pluck( $query->posts, 'ID' ) );
    288 
    289         $query = new WP_Query( array(
    290             'meta_query' => array(
    291                     array(
    292                         'key' => 'decimal_value',
    293                         'value' => array( 0.23409845, .31 ),
    294                         'compare' => 'NOT BETWEEN',
    295                         'type' => 'DECIMAL(10,10)'
    296                     )
    297                 ),
    298         ) );
    299         $this->assertEqualSets( array( $post_1, $post_2, $post_4 ), wp_list_pluck( $query->posts, 'ID' ) );
    300 
    301         $query = new WP_Query( array(
    302             'meta_query' => array(
    303                     array(
    304                         'key' => 'decimal_value',
    305                         'value' => '.3',
    306                         'compare' => 'LIKE',
    307                         'type' => 'DECIMAL(10,2)'
    308                     )
    309                 ),
    310         ) );
    311         $this->assertEqualSets( array( $post_1, $post_3 ), wp_list_pluck( $query->posts, 'ID' ) );
    312 
    313         $query = new WP_Query( array(
    314             'meta_query' => array(
    315                     array(
    316                         'key' => 'decimal_value',
    317                         'value' => '.3',
    318                         'compare' => 'NOT LIKE',
    319                         'type' => 'DECIMAL(10,2)'
    320                     )
    321                 ),
    322         ) );
    323         $this->assertEqualSets( array( $post_2, $post_4 ), wp_list_pluck( $query->posts, 'ID' ) );
     630                array(
     631                    'key' => 'decimal_value',
     632                    'value' => '.300',
     633                    'compare' => '=',
     634                    'type' => 'DECIMAL(10,2)'
     635                )
     636            ),
     637            'update_post_meta_cache' => false,
     638            'update_post_term_cache' => false,
     639            'fields' => 'ids',
     640        ) );
     641        $this->assertEqualSets( array( $post_3 ), $query->posts );
     642
     643        $query = new WP_Query( array(
     644            'meta_query' => array(
     645                array(
     646                    'key' => 'decimal_value',
     647                    'value' => '0.35',
     648                    'compare' => '>',
     649                    'type' => 'DECIMAL(10,2)'
     650                )
     651            ),
     652            'update_post_meta_cache' => false,
     653            'update_post_term_cache' => false,
     654            'fields' => 'ids',
     655        ) );
     656        $this->assertEqualSets( array( $post_4 ), $query->posts );
     657
     658        $query = new WP_Query( array(
     659            'meta_query' => array(
     660                array(
     661                    'key' => 'decimal_value',
     662                    'value' => '0.3',
     663                    'compare' => '>=',
     664                    'type' => 'DECIMAL(10,2)'
     665                )
     666            ),
     667            'update_post_meta_cache' => false,
     668            'update_post_term_cache' => false,
     669            'fields' => 'ids',
     670        ) );
     671        $this->assertEqualSets( array( $post_3, $post_4 ), $query->posts );
     672
     673        $query = new WP_Query( array(
     674            'meta_query' => array(
     675                array(
     676                    'key' => 'decimal_value',
     677                    'value' => '0',
     678                    'compare' => '<',
     679                    'type' => 'DECIMAL(10,2)'
     680                )
     681            ),
     682            'update_post_meta_cache' => false,
     683            'update_post_term_cache' => false,
     684            'fields' => 'ids',
     685        ) );
     686        $this->assertEqualSets( array( $post_1 ), $query->posts, 'ID' );
     687
     688        $query = new WP_Query( array(
     689            'meta_query' => array(
     690                array(
     691                    'key' => 'decimal_value',
     692                    'value' => '0.3',
     693                    'compare' => '<=',
     694                    'type' => 'DECIMAL(10,2)'
     695                )
     696            ),
     697            'update_post_meta_cache' => false,
     698            'update_post_term_cache' => false,
     699            'fields' => 'ids',
     700        ) );
     701        $this->assertEqualSets( array( $post_1, $post_2, $post_3 ), $query->posts );
     702
     703        $query = new WP_Query( array(
     704            'meta_query' => array(
     705                array(
     706                    'key' => 'decimal_value',
     707                    'value' => array( 0.23409845, .31 ),
     708                    'compare' => 'BETWEEN',
     709                    'type' => 'DECIMAL(10, 10)'
     710                )
     711            ),
     712            'update_post_meta_cache' => false,
     713            'update_post_term_cache' => false,
     714            'fields' => 'ids',
     715        ) );
     716        $this->assertEqualSets( array( $post_3 ), $query->posts );
     717
     718        $query = new WP_Query( array(
     719            'meta_query' => array(
     720                array(
     721                    'key' => 'decimal_value',
     722                    'value' => array( 0.23409845, .31 ),
     723                    'compare' => 'NOT BETWEEN',
     724                    'type' => 'DECIMAL(10,10)'
     725                )
     726            ),
     727            'update_post_meta_cache' => false,
     728            'update_post_term_cache' => false,
     729            'fields' => 'ids',
     730        ) );
     731        $this->assertEqualSets( array( $post_1, $post_2, $post_4 ), $query->posts );
     732
     733        $query = new WP_Query( array(
     734            'meta_query' => array(
     735                array(
     736                    'key' => 'decimal_value',
     737                    'value' => '.3',
     738                    'compare' => 'LIKE',
     739                    'type' => 'DECIMAL(10,2)'
     740                )
     741            ),
     742            'update_post_meta_cache' => false,
     743            'update_post_term_cache' => false,
     744            'fields' => 'ids',
     745        ) );
     746        $this->assertEqualSets( array( $post_1, $post_3 ), $query->posts );
     747
     748        $query = new WP_Query( array(
     749            'meta_query' => array(
     750                array(
     751                    'key' => 'decimal_value',
     752                    'value' => '.3',
     753                    'compare' => 'NOT LIKE',
     754                    'type' => 'DECIMAL(10,2)'
     755                )
     756            ),
     757            'update_post_meta_cache' => false,
     758            'update_post_term_cache' => false,
     759            'fields' => 'ids',
     760        ) );
     761        $this->assertEqualSets( array( $post_2, $post_4 ), $query->posts );
    324762
    325763        $query = new WP_Query( array(
    … …  
    327765            'order' => 'DESC',
    328766            'meta_key' => 'decimal_value',
    329             'meta_type' => 'DECIMAL(10, 2)'
    330         ) );
    331         $this->assertEqualSets( array( $post_4, $post_3, $post_2, $post_1 ), wp_list_pluck( $query->posts, 'ID' ) );
    332 
     767            'meta_type' => 'DECIMAL(10, 2)',
     768            'update_post_meta_cache' => false,
     769            'update_post_term_cache' => false,
     770            'fields' => 'ids',
     771        ) );
     772        $this->assertEqualSets( array( $post_4, $post_3, $post_2, $post_1 ), $query->posts );
    333773    }
    334774
Note: See TracChangeset for help on using the changeset viewer.