WordPress.org
Get WordPress

Make WordPress Core


Ignore:
Timestamp:
01/27/2015 08:03:50 PM (12 years ago)
Author:
boonebgorges
Message:

Improve organiation of tax_query and meta_query unit tests.

meta_query tests have been moved to tests/phpunit/tests/query/metaQuery.php and tax_query tests to tests/phpunit/tests/query/taxQuery.php. This is an improvement because (a) it better corresponds to the way that other WP_Query parameter tests are organized, (b) splitting meta and tax tests into separate classes simplifies the required @group annotations, and (c) the tests have nothing to do with posts per se, and so do not belong in the post subdirectory.

The tests previously found at tests/phpunit/tests/query/taxQuery.php have been moved to isTerm.php in the same directory. These tests are related to the is_* functions that have to do with taxonomy terms, like is_category().

See #26999.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r30771 r31286  
    22
    33/**
    4  * Test the is_*() functions in query.php across the URL structure
    5  *
    6  * This exercises both query.php and rewrite.php: urls are fed through the rewrite code,
    7  * then we test the effects of each url on the wp_query object.
    8  *
    94 * @group query
    10  * @group rewrite
     5 * @group taxonomy
    116 */
    127class Tests_Query_TaxQuery extends WP_UnitTestCase {
    13         protected $tag_id;
    14         protected $cat_id;
    15         protected $tax_id;
    16         protected $tax_id2;
    17         protected $post_id;
    18 
    19         protected $cat;
    20         protected $uncat;
    21         protected $tag;
    22         protected $tax;
    23 
    24         function setUp() {
    25                 global $wp_rewrite;
    26                 parent::setUp();
    27 
    28                 set_current_screen( 'front' );
    29 
    30                 $GLOBALS['wp_the_query'] = new WP_Query();
    31                 $GLOBALS['wp_query'] = $GLOBALS['wp_the_query'];
    32 
    33                 $wp_rewrite->init();
    34                 $wp_rewrite->set_permalink_structure( '/%year%/%monthnum%/%day%/%postname%/' );
    35 
    36                 create_initial_taxonomies();
    37                 register_taxonomy( 'testtax', 'post', array( 'public' => true ) );
    38 
    39                 $wp_rewrite->flush_rules();
    40 
    41                 $this->tag_id = $this->factory->tag->create( array( 'slug' => 'tag-slug' ) );
    42                 $this->cat_id = $this->factory->category->create( array( 'slug' => 'cat-slug' ) );
    43                 $this->tax_id = $this->factory->term->create( array( 'taxonomy' => 'testtax', 'slug' => 'tax-slug' ) );
    44                 $this->tax_id2 = $this->factory->term->create( array( 'taxonomy' => 'testtax', 'slug' => 'tax-slug2' ) );
    45                 $this->post_id = $this->factory->post->create();
    46                 wp_set_object_terms( $this->post_id, $this->cat_id, 'category' );
    47                 wp_set_object_terms( $this->post_id, array( $this->tax_id, $this->tax_id2 ), 'testtax' );
    48 
    49                 $this->cat = get_term( $this->cat_id, 'category' );
    50                 _make_cat_compat( $this->cat );
    51                 $this->tag = get_term( $this->tag_id, 'post_tag' );
    52 
    53                 $this->uncat = get_term_by( 'slug', 'uncategorized', 'category' );
    54                 _make_cat_compat( $this->uncat );
    55 
    56                 add_action( 'pre_get_posts', array( $this, 'pre_get_posts_tax_category_tax_query' ) );
    57         }
    58 
    59         function tearDown() {
    60                 global $wp_rewrite;
    61                 parent::tearDown();
    62 
    63                 _unregister_taxonomy( 'testtax' );
    64 
    65                 $wp_rewrite->init();
    66 
    67                 remove_action( 'pre_get_posts', array( $this, 'pre_get_posts_tax_category_tax_query' ) );
    68         }
    69 
    70         function test_tag_action_tax() {
    71                 // tag with tax added
    72                 $this->go_to( home_url( "/tag/tag-slug/" ) );
    73                 $this->assertQueryTrue( 'is_tag', 'is_archive' );
    74                 $this->assertNotEmpty( get_query_var( 'tax_query' ) );
    75                 $this->assertNotEmpty( get_query_var( 'taxonomy' ) );
    76                 $this->assertNotEmpty( get_query_var( 'term_id' ) );
    77                 $this->assertNotEmpty( get_query_var( 'tag_id' ) );
    78                 $this->assertEquals( get_queried_object(), $this->tag );
    79         }
    80 
    81         function test_tag_query_cat_action_tax() {
    82                 // tag + category with tax added
    83                 $this->go_to( home_url( "/tag/tag-slug/?cat=$this->cat_id" ) );
    84                 $this->assertQueryTrue( 'is_category', 'is_tag', 'is_archive' );
    85                 $this->assertNotEmpty( get_query_var( 'tax_query' ) );
    86                 $this->assertNotEmpty( get_query_var( 'taxonomy' ) );
    87                 $this->assertNotEmpty( get_query_var( 'term_id' ) );
    88                 $this->assertNotEmpty( get_query_var( 'cat' ) );
    89                 $this->assertNotEmpty( get_query_var( 'tag_id' ) );
    90                 $this->assertEquals( get_queried_object(), $this->cat );
    91         }
    92 
    93         function test_tag_query_cat_query_tax_action_tax() {
    94                 // tag + category + tax with tax added
    95                 $this->go_to( home_url( "/tag/tag-slug/?cat=$this->cat_id&testtax=tax-slug2" ) );
    96                 $this->assertQueryTrue( 'is_category', 'is_tag', 'is_tax', 'is_archive' );
    97                 $this->assertNotEmpty( get_query_var( 'tax_query' ) );
    98                 $this->assertNotEmpty( get_query_var( 'taxonomy' ) );
    99                 $this->assertNotEmpty( get_query_var( 'term_id' ) );
    100                 $this->assertNotEmpty( get_query_var( 'cat' ) );
    101                 $this->assertNotEmpty( get_query_var( 'tag_id' ) );
    102                 $this->assertNotEmpty( get_query_var( 'testtax' ) );
    103                 $this->assertEquals( get_queried_object(), $this->cat );
    104         }
    105 
    106         function test_cat_action_tax() {
    107                 // category with tax added
    108                 $this->go_to( home_url( "/category/cat-slug/" ) );
    109                 $this->assertQueryTrue( 'is_category', 'is_archive' );
    110                 $this->assertNotEmpty( get_query_var( 'cat' ) );
    111                 $this->assertNotEmpty( get_query_var( 'tax_query' ) );
    112                 $this->assertNotEmpty( get_query_var( 'taxonomy' ) );
    113                 $this->assertNotEmpty( get_query_var( 'term_id' ) );
    114                 $this->assertEquals( get_queried_object(), $this->cat );
     8        public function test_tax_query_single_query_single_term_field_slug() {
     9                $t = $this->factory->term->create( array(
     10                        'taxonomy' => 'category',
     11                        'slug' => 'foo',
     12                        'name' => 'Foo',
     13                ) );
     14                $p1 = $this->factory->post->create();
     15                $p2 = $this->factory->post->create();
     16
     17                wp_set_post_terms( $p1, $t, 'category' );
     18
     19                $q = new WP_Query( array(
     20                        'fields' => 'ids',
     21                        'update_post_meta_cache' => false,
     22                        'update_post_term_cache' => false,
     23                        'tax_query' => array(
     24                                array(
     25                                        'taxonomy' => 'category',
     26                                        'terms' => array( 'foo' ),
     27                                        'field' => 'slug',
     28                                ),
     29                        ),
     30                ) );
     31
     32                $this->assertEquals( array( $p1 ), $q->posts );
     33        }
     34
     35        public function test_tax_query_single_query_single_term_field_name() {
     36                $t = $this->factory->term->create( array(
     37                        'taxonomy' => 'category',
     38                        'slug' => 'foo',
     39                        'name' => 'Foo',
     40                ) );
     41                $p1 = $this->factory->post->create();
     42                $p2 = $this->factory->post->create();
     43
     44                wp_set_post_terms( $p1, $t, 'category' );
     45
     46                $q = new WP_Query( array(
     47                        'fields' => 'ids',
     48                        'update_post_meta_cache' => false,
     49                        'update_post_term_cache' => false,
     50                        'tax_query' => array(
     51                                array(
     52                                        'taxonomy' => 'category',
     53                                        'terms' => array( 'Foo' ),
     54                                        'field' => 'name',
     55                                ),
     56                        ),
     57                ) );
     58
     59                $this->assertEquals( array( $p1 ), $q->posts );
     60        }
     61
     62        public function test_tax_query_single_query_single_term_field_term_taxonomy_id() {
     63                $t = $this->factory->term->create( array(
     64                        'taxonomy' => 'category',
     65                        'slug' => 'foo',
     66                        'name' => 'Foo',
     67                ) );
     68                $p1 = $this->factory->post->create();
     69                $p2 = $this->factory->post->create();
     70
     71                $tt_ids = wp_set_post_terms( $p1, $t, 'category' );
     72
     73                $q = new WP_Query( array(
     74                        'fields' => 'ids',
     75                        'update_post_meta_cache' => false,
     76                        'update_post_term_cache' => false,
     77                        'tax_query' => array(
     78                                array(
     79                                        'taxonomy' => 'category',
     80                                        'terms' => $tt_ids,
     81                                        'field' => 'term_taxonomy_id',
     82                                ),
     83                        ),
     84                ) );
     85
     86                $this->assertEquals( array( $p1 ), $q->posts );
     87        }
     88
     89        public function test_tax_query_single_query_single_term_field_term_id() {
     90                $t = $this->factory->term->create( array(
     91                        'taxonomy' => 'category',
     92                        'slug' => 'foo',
     93                        'name' => 'Foo',
     94                ) );
     95                $p1 = $this->factory->post->create();
     96                $p2 = $this->factory->post->create();
     97
     98                wp_set_post_terms( $p1, $t, 'category' );
     99
     100                $q = new WP_Query( array(
     101                        'fields' => 'ids',
     102                        'update_post_meta_cache' => false,
     103                        'update_post_term_cache' => false,
     104                        'tax_query' => array(
     105                                array(
     106                                        'taxonomy' => 'category',
     107                                        'terms' => array( $t ),
     108                                        'field' => 'term_id',
     109                                ),
     110                        ),
     111                ) );
     112
     113                $this->assertEquals( array( $p1 ), $q->posts );
     114        }
     115
     116        public function test_tax_query_single_query_single_term_operator_in() {
     117                $t = $this->factory->term->create( array(
     118                        'taxonomy' => 'category',
     119                        'slug' => 'foo',
     120                        'name' => 'Foo',
     121                ) );
     122                $p1 = $this->factory->post->create();
     123                $p2 = $this->factory->post->create();
     124
     125                wp_set_post_terms( $p1, $t, 'category' );
     126
     127                $q = new WP_Query( array(
     128                        'fields' => 'ids',
     129                        'update_post_meta_cache' => false,
     130                        'update_post_term_cache' => false,
     131                        'tax_query' => array(
     132                                array(
     133                                        'taxonomy' => 'category',
     134                                        'terms' => array( 'foo' ),
     135                                        'field' => 'slug',
     136                                        'operator' => 'IN',
     137                                ),
     138                        ),
     139                ) );
     140
     141                $this->assertEquals( array( $p1 ), $q->posts );
     142        }
     143
     144        public function test_tax_query_single_query_single_term_operator_not_in() {
     145                $t = $this->factory->term->create( array(
     146                        'taxonomy' => 'category',
     147                        'slug' => 'foo',
     148                        'name' => 'Foo',
     149                ) );
     150                $p1 = $this->factory->post->create();
     151                $p2 = $this->factory->post->create();
     152
     153                wp_set_post_terms( $p1, $t, 'category' );
     154
     155                $q = new WP_Query( array(
     156                        'fields' => 'ids',
     157                        'update_post_meta_cache' => false,
     158                        'update_post_term_cache' => false,
     159                        'tax_query' => array(
     160                                array(
     161                                        'taxonomy' => 'category',
     162                                        'terms' => array( 'foo' ),
     163                                        'field' => 'slug',
     164                                        'operator' => 'NOT IN',
     165                                ),
     166                        ),
     167                ) );
     168
     169                $this->assertEquals( array( $p2 ), $q->posts );
     170        }
     171
     172        public function test_tax_query_single_query_single_term_operator_and() {
     173                $t = $this->factory->term->create( array(
     174                        'taxonomy' => 'category',
     175                        'slug' => 'foo',
     176                        'name' => 'Foo',
     177                ) );
     178                $p1 = $this->factory->post->create();
     179                $p2 = $this->factory->post->create();
     180
     181                wp_set_post_terms( $p1, $t, 'category' );
     182
     183                $q = new WP_Query( array(
     184                        'fields' => 'ids',
     185                        'update_post_meta_cache' => false,
     186                        'update_post_term_cache' => false,
     187                        'tax_query' => array(
     188                                array(
     189                                        'taxonomy' => 'category',
     190                                        'terms' => array( 'foo' ),
     191                                        'field' => 'slug',
     192                                        'operator' => 'AND',
     193                                ),
     194                        ),
     195                ) );
     196
     197                $this->assertEquals( array( $p1 ), $q->posts );
     198        }
     199
     200        public function test_tax_query_single_query_multiple_terms_operator_in() {
     201                $t1 = $this->factory->term->create( array(
     202                        'taxonomy' => 'category',
     203                        'slug' => 'foo',
     204                        'name' => 'Foo',
     205                ) );
     206                $t2 = $this->factory->term->create( array(
     207                        'taxonomy' => 'category',
     208                        'slug' => 'bar',
     209                        'name' => 'Bar',
     210                ) );
     211                $p1 = $this->factory->post->create();
     212                $p2 = $this->factory->post->create();
     213                $p3 = $this->factory->post->create();
     214
     215                wp_set_post_terms( $p1, $t1, 'category' );
     216                wp_set_post_terms( $p2, $t2, 'category' );
     217
     218                $q = new WP_Query( array(
     219                        'fields' => 'ids',
     220                        'update_post_meta_cache' => false,
     221                        'update_post_term_cache' => false,
     222                        'tax_query' => array(
     223                                array(
     224                                        'taxonomy' => 'category',
     225                                        'terms' => array( 'foo', 'bar' ),
     226                                        'field' => 'slug',
     227                                        'operator' => 'IN',
     228                                ),
     229                        ),
     230                ) );
     231
     232                $this->assertEqualSets( array( $p1, $p2 ), $q->posts );
     233        }
     234
     235        public function test_tax_query_single_query_multiple_terms_operator_not_in() {
     236                $t1 = $this->factory->term->create( array(
     237                        'taxonomy' => 'category',
     238                        'slug' => 'foo',
     239                        'name' => 'Foo',
     240                ) );
     241                $t2 = $this->factory->term->create( array(
     242                        'taxonomy' => 'category',
     243                        'slug' => 'bar',
     244                        'name' => 'Bar',
     245                ) );
     246                $p1 = $this->factory->post->create();
     247                $p2 = $this->factory->post->create();
     248                $p3 = $this->factory->post->create();
     249
     250                wp_set_post_terms( $p1, $t1, 'category' );
     251                wp_set_post_terms( $p2, $t2, 'category' );
     252
     253                $q = new WP_Query( array(
     254                        'fields' => 'ids',
     255                        'update_post_meta_cache' => false,
     256                        'update_post_term_cache' => false,
     257                        'tax_query' => array(
     258                                array(
     259                                        'taxonomy' => 'category',
     260                                        'terms' => array( 'foo', 'bar' ),
     261                                        'field' => 'slug',
     262                                        'operator' => 'NOT IN',
     263                                ),
     264                        ),
     265                ) );
     266
     267                $this->assertEquals( array( $p3 ), $q->posts );
    115268        }
    116269
    117270        /**
    118          * @ticket 26627
     271         * @ticket 18105
    119272         */
    120         function test_cat_uncat_action_tax() {
    121                 // category with tax added
    122                 add_action( 'pre_get_posts', array( $this, '_cat_uncat_action_tax' ), 11 );
    123 
    124                 $this->go_to( home_url( "/category/uncategorized/" ) );
    125                 $this->assertQueryTrue( 'is_category', 'is_archive' );
    126                 $this->assertNotEmpty( get_query_var( 'cat' ) );
    127                 $this->assertNotEmpty( get_query_var( 'tax_query' ) );
    128                 $this->assertNotEmpty( get_query_var( 'taxonomy' ) );
    129                 $this->assertNotEmpty( get_query_var( 'term_id' ) );
    130                 $this->assertEquals( get_queried_object(), $this->uncat );
    131 
    132                 remove_action( 'pre_get_posts', array( $this, '_cat_uncat_action_tax' ), 11 );
    133         }
    134 
    135         function _cat_uncat_action_tax( &$query ) {
    136                 $this->assertTrue( $query->is_category() );
    137                 $this->assertTrue( $query->is_archive() );
    138                 $this->assertNotEmpty( $query->get( 'category_name' ) );
    139                 $this->assertNotEmpty( $query->get( 'tax_query' ) );
    140                 $this->assertEquals( $query->get_queried_object(), $this->uncat );
     273        public function test_tax_query_single_query_multiple_queries_operator_not_in() {
     274                $t1 = $this->factory->term->create( array(
     275                        'taxonomy' => 'category',
     276                        'slug' => 'foo',
     277                        'name' => 'Foo',
     278                ) );
     279                $t2 = $this->factory->term->create( array(
     280                        'taxonomy' => 'category',
     281                        'slug' => 'bar',
     282                        'name' => 'Bar',
     283                ) );
     284                $p1 = $this->factory->post->create();
     285                $p2 = $this->factory->post->create();
     286                $p3 = $this->factory->post->create();
     287
     288                wp_set_post_terms( $p1, $t1, 'category' );
     289                wp_set_post_terms( $p2, $t2, 'category' );
     290
     291                $q = new WP_Query( array(
     292                        'fields' => 'ids',
     293                        'update_post_meta_cache' => false,
     294                        'update_post_term_cache' => false,
     295                        'tax_query' => array(
     296                                'relation' => 'AND',
     297                                array(
     298                                        'taxonomy' => 'category',
     299                                        'terms' => array( 'foo' ),
     300                                        'field' => 'slug',
     301                                        'operator' => 'NOT IN',
     302                                ),
     303                                array(
     304                                        'taxonomy' => 'category',
     305                                        'terms' => array( 'bar' ),
     306                                        'field' => 'slug',
     307                                        'operator' => 'NOT IN',
     308                                ),
     309                        ),
     310                ) );
     311
     312                $this->assertEquals( array( $p3 ), $q->posts );
     313        }
     314
     315        public function test_tax_query_single_query_multiple_terms_operator_and() {
     316                $t1 = $this->factory->term->create( array(
     317                        'taxonomy' => 'category',
     318                        'slug' => 'foo',
     319                        'name' => 'Foo',
     320                ) );
     321                $t2 = $this->factory->term->create( array(
     322                        'taxonomy' => 'category',
     323                        'slug' => 'bar',
     324                        'name' => 'Bar',
     325                ) );
     326                $p1 = $this->factory->post->create();
     327                $p2 = $this->factory->post->create();
     328                $p3 = $this->factory->post->create();
     329
     330                wp_set_object_terms( $p1, $t1, 'category' );
     331                wp_set_object_terms( $p2, array( $t1, $t2 ), 'category' );
     332
     333                $q = new WP_Query( array(
     334                        'fields' => 'ids',
     335                        'update_post_meta_cache' => false,
     336                        'update_post_term_cache' => false,
     337                        'tax_query' => array(
     338                                array(
     339                                        'taxonomy' => 'category',
     340                                        'terms' => array( 'foo', 'bar' ),
     341                                        'field' => 'slug',
     342                                        'operator' => 'AND',
     343                                ),
     344                        ),
     345                ) );
     346
     347                $this->assertEquals( array( $p2 ), $q->posts );
    141348        }
    142349
    143350        /**
    144          * @ticket 26728
     351         * @ticket 29181
    145352         */
    146         function test_tax_action_tax() {
    147                 // tax with tax added
    148                 $this->go_to( home_url( '/testtax/tax-slug2/' ) );
    149                 $this->assertQueryTrue( 'is_tax', 'is_archive' );
    150                 $this->assertNotEmpty( get_query_var( 'tax_query' ) );
    151                 $this->assertNotEmpty( get_query_var( 'taxonomy' ) );
    152                 $this->assertNotEmpty( get_query_var( 'term_id' ) );
    153                 $this->assertEquals( get_queried_object(), get_term( $this->tax_id, 'testtax' ) );
    154         }
    155 
    156         function test_tax_query_tag_action_tax() {
    157                 // tax + tag with tax added
    158                 $this->go_to( home_url( "/testtax/tax-slug2/?tag_id=$this->tag_id" ) );
    159                 $this->assertQueryTrue( 'is_tag', 'is_tax', 'is_archive' );
    160                 $this->assertNotEmpty( get_query_var( 'tax_query' ) );
    161                 $this->assertNotEmpty( get_query_var( 'taxonomy' ) );
    162                 $this->assertNotEmpty( get_query_var( 'term_id' ) );
    163                 $this->assertNotEmpty( get_query_var( 'tag_id' ) );
    164                 $this->assertEquals( get_queried_object(), $this->tag );
    165         }
    166 
    167         function test_tax_query_cat_action_tax() {
    168                 // tax + cat with tax added
    169                 $this->go_to( home_url( "/testtax/tax-slug2/?cat=$this->cat_id" ) );
    170                 $this->assertQueryTrue( 'is_category', 'is_tax', 'is_archive' );
    171                 $this->assertNotEmpty( get_query_var( 'tax_query' ) );
    172                 $this->assertNotEmpty( get_query_var( 'taxonomy' ) );
    173                 $this->assertNotEmpty( get_query_var( 'term_id' ) );
    174                 $this->assertNotEmpty( get_query_var( 'cat' ) );
    175                 $this->assertEquals( get_queried_object(), $this->cat );
    176         }
    177 
    178         function pre_get_posts_tax_category_tax_query( &$query ) {
    179                 $query->set( 'tax_query', array(
    180                         array( 'taxonomy' => 'testtax', 'field' => 'term_id', 'terms' => $this->tax_id )
    181                 ) );
     353        public function test_tax_query_operator_not_exists() {
     354                register_taxonomy( 'wptests_tax1', 'post' );
     355                register_taxonomy( 'wptests_tax2', 'post' );
     356
     357                $t1 = $this->factory->term->create( array( 'taxonomy' => 'wptests_tax1' ) );
     358                $t2 = $this->factory->term->create( array( 'taxonomy' => 'wptests_tax2' ) );
     359
     360                $p1 = $this->factory->post->create();
     361                $p2 = $this->factory->post->create();
     362                $p3 = $this->factory->post->create();
     363
     364                wp_set_object_terms( $p1, array( $t1 ), 'wptests_tax1' );
     365                wp_set_object_terms( $p2, array( $t2 ), 'wptests_tax2' );
     366
     367                $q = new WP_Query( array(
     368                        'fields' => 'ids',
     369                        'orderby' => 'ID',
     370                        'order' => 'ASC',
     371                        'tax_query' => array(
     372                                array(
     373                                        'taxonomy' => 'wptests_tax2',
     374                                        'operator' => 'NOT EXISTS',
     375                                ),
     376                        ),
     377                ) );
     378
     379                $this->assertEqualSets( array( $p1, $p3 ), $q->posts );
    182380        }
    183381
    184382        /**
    185          * @group 30623
     383         * @ticket 29181
    186384         */
    187         public function test_get_queried_object_with_custom_taxonomy_tax_query_and_field_term_id_should_return_term_object() {
    188                 // Don't override the args provided below.
    189                 remove_action( 'pre_get_posts', array( $this, 'pre_get_posts_tax_category_tax_query' ) );
    190 
    191                 $args = array(
     385        public function test_tax_query_operator_exists() {
     386                register_taxonomy( 'wptests_tax1', 'post' );
     387                register_taxonomy( 'wptests_tax2', 'post' );
     388
     389                $t1 = $this->factory->term->create( array( 'taxonomy' => 'wptests_tax1' ) );
     390                $t2 = $this->factory->term->create( array( 'taxonomy' => 'wptests_tax2' ) );
     391
     392                $p1 = $this->factory->post->create();
     393                $p2 = $this->factory->post->create();
     394                $p3 = $this->factory->post->create();
     395
     396                wp_set_object_terms( $p1, array( $t1 ), 'wptests_tax1' );
     397                wp_set_object_terms( $p2, array( $t2 ), 'wptests_tax2' );
     398
     399                $q = new WP_Query( array(
     400                        'fields' => 'ids',
     401                        'orderby' => 'ID',
     402                        'order' => 'ASC',
     403                        'tax_query' => array(
     404                                array(
     405                                        'taxonomy' => 'wptests_tax2',
     406                                        'operator' => 'EXISTS',
     407                                ),
     408                        ),
     409                ) );
     410
     411                $this->assertEqualSets( array( $p2 ), $q->posts );
     412        }
     413
     414        /**
     415         * @ticket 29181
     416         */
     417        public function test_tax_query_operator_exists_should_ignore_terms() {
     418                register_taxonomy( 'wptests_tax1', 'post' );
     419                register_taxonomy( 'wptests_tax2', 'post' );
     420
     421                $t1 = $this->factory->term->create( array( 'taxonomy' => 'wptests_tax1' ) );
     422                $t2 = $this->factory->term->create( array( 'taxonomy' => 'wptests_tax2' ) );
     423
     424                $p1 = $this->factory->post->create();
     425                $p2 = $this->factory->post->create();
     426                $p3 = $this->factory->post->create();
     427
     428                wp_set_object_terms( $p1, array( $t1 ), 'wptests_tax1' );
     429                wp_set_object_terms( $p2, array( $t2 ), 'wptests_tax2' );
     430
     431                $q = new WP_Query( array(
     432                        'fields' => 'ids',
     433                        'orderby' => 'ID',
     434                        'order' => 'ASC',
     435                        'tax_query' => array(
     436                                array(
     437                                        'taxonomy' => 'wptests_tax2',
     438                                        'operator' => 'EXISTS',
     439                                        'terms' => array( 'foo', 'bar' ),
     440                                ),
     441                        ),
     442                ) );
     443
     444                $this->assertEqualSets( array( $p2 ), $q->posts );
     445        }
     446
     447        /**
     448         * @ticket 29181
     449         */
     450        public function test_tax_query_operator_exists_with_no_taxonomy() {
     451                register_taxonomy( 'wptests_tax1', 'post' );
     452                register_taxonomy( 'wptests_tax2', 'post' );
     453
     454                $t1 = $this->factory->term->create( array( 'taxonomy' => 'wptests_tax1' ) );
     455                $t2 = $this->factory->term->create( array( 'taxonomy' => 'wptests_tax2' ) );
     456
     457                $p1 = $this->factory->post->create();
     458                $p2 = $this->factory->post->create();
     459                $p3 = $this->factory->post->create();
     460
     461                wp_set_object_terms( $p1, array( $t1 ), 'wptests_tax1' );
     462                wp_set_object_terms( $p2, array( $t2 ), 'wptests_tax2' );
     463
     464                $q = new WP_Query( array(
     465                        'fields' => 'ids',
     466                        'orderby' => 'ID',
     467                        'order' => 'ASC',
     468                        'tax_query' => array(
     469                                array(
     470                                        'operator' => 'EXISTS',
     471                                ),
     472                        ),
     473                ) );
     474
     475                $this->assertEmpty( $q->posts );
     476        }
     477
     478        public function test_tax_query_multiple_queries_relation_and() {
     479                $t1 = $this->factory->term->create( array(
     480                        'taxonomy' => 'category',
     481                        'slug' => 'foo',
     482                        'name' => 'Foo',
     483                ) );
     484                $t2 = $this->factory->term->create( array(
     485                        'taxonomy' => 'category',
     486                        'slug' => 'bar',
     487                        'name' => 'Bar',
     488                ) );
     489                $p1 = $this->factory->post->create();
     490                $p2 = $this->factory->post->create();
     491                $p3 = $this->factory->post->create();
     492
     493                wp_set_object_terms( $p1, $t1, 'category' );
     494                wp_set_object_terms( $p2, array( $t1, $t2 ), 'category' );
     495
     496                $q = new WP_Query( array(
     497                        'fields' => 'ids',
     498                        'update_post_meta_cache' => false,
     499                        'update_post_term_cache' => false,
    192500                        'tax_query' => array(
    193501                                'relation' => 'AND',
    194502                                array(
    195                                         'taxonomy' => 'testtax',
     503                                        'taxonomy' => 'category',
     504                                        'terms' => array( 'foo' ),
     505                                        'field' => 'slug',
     506                                ),
     507                                array(
     508                                        'taxonomy' => 'category',
     509                                        'terms' => array( 'bar' ),
     510                                        'field' => 'slug',
     511                                ),
     512                        ),
     513                ) );
     514
     515                $this->assertEquals( array( $p2 ), $q->posts );
     516        }
     517
     518        public function test_tax_query_multiple_queries_relation_or() {
     519                $t1 = $this->factory->term->create( array(
     520                        'taxonomy' => 'category',
     521                        'slug' => 'foo',
     522                        'name' => 'Foo',
     523                ) );
     524                $t2 = $this->factory->term->create( array(
     525                        'taxonomy' => 'category',
     526                        'slug' => 'bar',
     527                        'name' => 'Bar',
     528                ) );
     529                $p1 = $this->factory->post->create();
     530                $p2 = $this->factory->post->create();
     531                $p3 = $this->factory->post->create();
     532
     533                wp_set_object_terms( $p1, $t1, 'category' );
     534                wp_set_object_terms( $p2, array( $t1, $t2 ), 'category' );
     535
     536                $q = new WP_Query( array(
     537                        'fields' => 'ids',
     538                        'update_post_meta_cache' => false,
     539                        'update_post_term_cache' => false,
     540                        'tax_query' => array(
     541                                'relation' => 'OR',
     542                                array(
     543                                        'taxonomy' => 'category',
     544                                        'terms' => array( 'foo' ),
     545                                        'field' => 'slug',
     546                                ),
     547                                array(
     548                                        'taxonomy' => 'category',
     549                                        'terms' => array( 'bar' ),
     550                                        'field' => 'slug',
     551                                ),
     552                        ),
     553                ) );
     554
     555                $this->assertEqualSets( array( $p1, $p2 ), $q->posts );
     556        }
     557
     558        public function test_tax_query_multiple_queries_different_taxonomies() {
     559                $t1 = $this->factory->term->create( array(
     560                        'taxonomy' => 'post_tag',
     561                        'slug' => 'foo',
     562                        'name' => 'Foo',
     563                ) );
     564                $t2 = $this->factory->term->create( array(
     565                        'taxonomy' => 'category',
     566                        'slug' => 'bar',
     567                        'name' => 'Bar',
     568                ) );
     569                $p1 = $this->factory->post->create();
     570                $p2 = $this->factory->post->create();
     571                $p3 = $this->factory->post->create();
     572
     573                wp_set_object_terms( $p1, $t1, 'post_tag' );
     574                wp_set_object_terms( $p2, $t2, 'category' );
     575
     576                $q = new WP_Query( array(
     577                        'fields' => 'ids',
     578                        'update_post_meta_cache' => false,
     579                        'update_post_term_cache' => false,
     580                        'tax_query' => array(
     581                                'relation' => 'OR',
     582                                array(
     583                                        'taxonomy' => 'post_tag',
     584                                        'terms' => array( 'foo' ),
     585                                        'field' => 'slug',
     586                                ),
     587                                array(
     588                                        'taxonomy' => 'category',
     589                                        'terms' => array( 'bar' ),
     590                                        'field' => 'slug',
     591                                ),
     592                        ),
     593                ) );
     594
     595                $this->assertEqualSets( array( $p1, $p2 ), $q->posts );
     596        }
     597
     598        /**
     599         * @ticket 29738
     600         */
     601        public function test_tax_query_two_nested_queries() {
     602                register_taxonomy( 'foo', 'post' );
     603                register_taxonomy( 'bar', 'post' );
     604
     605                $foo_term_1 = $this->factory->term->create( array(
     606                        'taxonomy' => 'foo',
     607                ) );
     608                $foo_term_2 = $this->factory->term->create( array(
     609                        'taxonomy' => 'foo',
     610                ) );
     611                $bar_term_1 = $this->factory->term->create( array(
     612                        'taxonomy' => 'bar',
     613                ) );
     614                $bar_term_2 = $this->factory->term->create( array(
     615                        'taxonomy' => 'bar',
     616                ) );
     617
     618                $p1 = $this->factory->post->create();
     619                $p2 = $this->factory->post->create();
     620                $p3 = $this->factory->post->create();
     621
     622                wp_set_object_terms( $p1, array( $foo_term_1 ), 'foo' );
     623                wp_set_object_terms( $p1, array( $bar_term_1 ), 'bar' );
     624                wp_set_object_terms( $p2, array( $foo_term_2 ), 'foo' );
     625                wp_set_object_terms( $p2, array( $bar_term_2 ), 'bar' );
     626                wp_set_object_terms( $p3, array( $foo_term_1 ), 'foo' );
     627                wp_set_object_terms( $p3, array( $bar_term_2 ), 'bar' );
     628
     629                $q = new WP_Query( array(
     630                        'fields' => 'ids',
     631                        'update_post_meta_cache' => false,
     632                        'update_post_term_cache' => false,
     633                        'tax_query' => array(
     634                                'relation' => 'OR',
     635                                array(
     636                                        'relation' => 'AND',
     637                                        array(
     638                                                'taxonomy' => 'foo',
     639                                                'terms' => array( $foo_term_1 ),
     640                                                'field' => 'term_id',
     641                                        ),
     642                                        array(
     643                                                'taxonomy' => 'bar',
     644                                                'terms' => array( $bar_term_1 ),
     645                                                'field' => 'term_id',
     646                                        ),
     647                                ),
     648                                array(
     649                                        'relation' => 'AND',
     650                                        array(
     651                                                'taxonomy' => 'foo',
     652                                                'terms' => array( $foo_term_2 ),
     653                                                'field' => 'term_id',
     654                                        ),
     655                                        array(
     656                                                'taxonomy' => 'bar',
     657                                                'terms' => array( $bar_term_2 ),
     658                                                'field' => 'term_id',
     659                                        ),
     660                                ),
     661                        ),
     662                ) );
     663
     664                _unregister_taxonomy( 'foo' );
     665                _unregister_taxonomy( 'bar' );
     666
     667                $this->assertEqualSets( array( $p1, $p2 ), $q->posts );
     668        }
     669
     670        /**
     671         * @ticket 29738
     672         */
     673        public function test_tax_query_one_nested_query_one_first_order_query() {
     674                register_taxonomy( 'foo', 'post' );
     675                register_taxonomy( 'bar', 'post' );
     676
     677                $foo_term_1 = $this->factory->term->create( array(
     678                        'taxonomy' => 'foo',
     679                ) );
     680                $foo_term_2 = $this->factory->term->create( array(
     681                        'taxonomy' => 'foo',
     682                ) );
     683                $bar_term_1 = $this->factory->term->create( array(
     684                        'taxonomy' => 'bar',
     685                ) );
     686                $bar_term_2 = $this->factory->term->create( array(
     687                        'taxonomy' => 'bar',
     688                ) );
     689
     690                $p1 = $this->factory->post->create();
     691                $p2 = $this->factory->post->create();
     692                $p3 = $this->factory->post->create();
     693
     694                wp_set_object_terms( $p1, array( $foo_term_1 ), 'foo' );
     695                wp_set_object_terms( $p1, array( $bar_term_1 ), 'bar' );
     696                wp_set_object_terms( $p2, array( $foo_term_2 ), 'foo' );
     697                wp_set_object_terms( $p2, array( $bar_term_2 ), 'bar' );
     698                wp_set_object_terms( $p3, array( $foo_term_1 ), 'foo' );
     699                wp_set_object_terms( $p3, array( $bar_term_2 ), 'bar' );
     700
     701                $q = new WP_Query( array(
     702                        'fields' => 'ids',
     703                        'update_post_meta_cache' => false,
     704                        'update_post_term_cache' => false,
     705                        'tax_query' => array(
     706                                'relation' => 'OR',
     707                                array(
     708                                        'taxonomy' => 'foo',
     709                                        'terms' => array( $foo_term_2 ),
    196710                                        'field' => 'term_id',
    197                                         'terms' => array(
    198                                                 $this->tax_id,
     711                                ),
     712                                array(
     713                                        'relation' => 'AND',
     714                                        array(
     715                                                'taxonomy' => 'foo',
     716                                                'terms' => array( $foo_term_1 ),
     717                                                'field' => 'term_id',
    199718                                        ),
     719                                        array(
     720                                                'taxonomy' => 'bar',
     721                                                'terms' => array( $bar_term_1 ),
     722                                                'field' => 'term_id',
     723                                        ),
     724                                ),
     725                        ),
     726                ) );
     727
     728                _unregister_taxonomy( 'foo' );
     729                _unregister_taxonomy( 'bar' );
     730
     731                $this->assertEqualSets( array( $p1, $p2 ), $q->posts );
     732        }
     733
     734        /**
     735         * @ticket 29738
     736         */
     737        public function test_tax_query_one_double_nested_query_one_first_order_query() {
     738                register_taxonomy( 'foo', 'post' );
     739                register_taxonomy( 'bar', 'post' );
     740
     741                $foo_term_1 = $this->factory->term->create( array(
     742                        'taxonomy' => 'foo',
     743                ) );
     744                $foo_term_2 = $this->factory->term->create( array(
     745                        'taxonomy' => 'foo',
     746                ) );
     747                $bar_term_1 = $this->factory->term->create( array(
     748                        'taxonomy' => 'bar',
     749                ) );
     750                $bar_term_2 = $this->factory->term->create( array(
     751                        'taxonomy' => 'bar',
     752                ) );
     753
     754                $p1 = $this->factory->post->create();
     755                $p2 = $this->factory->post->create();
     756                $p3 = $this->factory->post->create();
     757                $p4 = $this->factory->post->create();
     758
     759                wp_set_object_terms( $p1, array( $foo_term_1 ), 'foo' );
     760                wp_set_object_terms( $p1, array( $bar_term_1 ), 'bar' );
     761                wp_set_object_terms( $p2, array( $foo_term_2 ), 'foo' );
     762                wp_set_object_terms( $p2, array( $bar_term_2 ), 'bar' );
     763                wp_set_object_terms( $p3, array( $foo_term_1 ), 'foo' );
     764                wp_set_object_terms( $p3, array( $bar_term_2 ), 'bar' );
     765
     766                $q = new WP_Query( array(
     767                        'fields' => 'ids',
     768                        'update_post_meta_cache' => false,
     769                        'update_post_term_cache' => false,
     770                        'tax_query' => array(
     771                                'relation' => 'OR',
     772                                array(
     773                                        'taxonomy' => 'foo',
     774                                        'terms' => array( $foo_term_2 ),
     775                                        'field' => 'term_id',
     776                                ),
     777                                array(
     778                                        'relation' => 'AND',
     779                                        array(
     780                                                'taxonomy' => 'foo',
     781                                                'terms' => array( $foo_term_1 ),
     782                                                'field' => 'term_id',
     783                                        ),
     784                                        array(
     785                                                'relation' => 'OR',
     786                                                array(
     787                                                        'taxonomy' => 'bar',
     788                                                        'terms' => array( $bar_term_1 ),
     789                                                        'field' => 'term_id',
     790                                                ),
     791                                                array(
     792                                                        'taxonomy' => 'bar',
     793                                                        'terms' => array( $bar_term_2 ),
     794                                                        'field' => 'term_id',
     795                                                ),
     796                                        ),
     797                                ),
     798                        ),
     799                ) );
     800
     801                _unregister_taxonomy( 'foo' );
     802                _unregister_taxonomy( 'bar' );
     803
     804                $this->assertEqualSets( array( $p1, $p2, $p3 ), $q->posts );
     805        }
     806
     807        /**
     808         * @ticket 20604
     809         */
     810        public function test_tax_query_relation_or_both_clauses_empty_terms() {
     811                // An empty tax query should return an empty array, not all posts.
     812
     813                $this->factory->post->create_many( 10 );
     814
     815                $query = new WP_Query( array(
     816                        'fields' => 'ids',
     817                        'update_post_term_cache' => false,
     818                        'update_post_meta_cache' => false,
     819                        'tax_query' => array(
     820                                'relation' => 'OR',
     821                                array(
     822                                        'taxonomy' => 'post_tag',
     823                                        'field' => 'id',
     824                                        'terms' => false,
     825                                        'operator' => 'IN'
     826                                ),
     827                                array(
     828                                        'taxonomy' => 'category',
     829                                        'field' => 'id',
     830                                        'terms' => false,
     831                                        'operator' => 'IN'
    200832                                ),
    201833                        )
    202                 );
    203 
    204                 $q = new WP_Query( $args );
    205                 $object = $q->get_queried_object();
    206 
    207                 $expected = get_term( $this->tax_id, 'testtax' );
    208 
    209                 $this->assertEquals( $expected, $object );
     834                ) );
     835
     836                $posts = $query->get_posts();
     837                $this->assertEquals( 0 , count( $posts ) );
    210838        }
    211839
    212840        /**
    213          * @group 30623
     841         * @ticket 20604
    214842         */
    215         public function test_get_queried_object_with_custom_taxonomy_tax_query_and_field_slug_should_return_term_object() {
    216                 // Don't override the args provided below.
    217                 remove_action( 'pre_get_posts', array( $this, 'pre_get_posts_tax_category_tax_query' ) );
    218 
    219                 $args = array(
     843        public function test_tax_query_relation_or_one_clause_empty_terms() {
     844                // An empty tax query should return an empty array, not all posts.
     845
     846                $this->factory->post->create_many( 10 );
     847
     848                $query = new WP_Query( array(
     849                        'fields' => 'ids',
     850                        'update_post_term_cache' => false,
     851                        'update_post_meta_cache' => false,
     852                        'tax_query' => array(
     853                                'relation' => 'OR',
     854                                array(
     855                                        'taxonomy' => 'post_tag',
     856                                        'field' => 'id',
     857                                        'terms' => array( 'foo' ),
     858                                        'operator' => 'IN'
     859                                ),
     860                                array(
     861                                        'taxonomy' => 'category',
     862                                        'field' => 'id',
     863                                        'terms' => false,
     864                                        'operator' => 'IN'
     865                                ),
     866                        )
     867                ) );
     868
     869                $posts = $query->get_posts();
     870                $this->assertEquals( 0 , count( $posts ) );
     871        }
     872
     873        public function test_tax_query_include_children() {
     874                $cat_a = $this->factory->term->create( array( 'taxonomy' => 'category', 'name' => 'Australia' ) );
     875                $cat_b = $this->factory->term->create( array( 'taxonomy' => 'category', 'name' => 'Sydney', 'parent' => $cat_a ) );
     876                $cat_c = $this->factory->term->create( array( 'taxonomy' => 'category', 'name' => 'East Syndney', 'parent' => $cat_b ) );
     877                $cat_d = $this->factory->term->create( array( 'taxonomy' => 'category', 'name' => 'West Syndney', 'parent' => $cat_b ) );
     878
     879                $post_a = $this->factory->post->create( array( 'post_category' => array( $cat_a ) ) );
     880                $post_b = $this->factory->post->create( array( 'post_category' => array( $cat_b ) ) );
     881                $post_c = $this->factory->post->create( array( 'post_category' => array( $cat_c ) ) );
     882                $post_d = $this->factory->post->create( array( 'post_category' => array( $cat_d ) ) );
     883
     884                $posts = get_posts( array(
     885                        'fields' => 'ids',
     886                        'update_post_meta_cache' => false,
     887                        'update_post_term_cache' => false,
     888                        'tax_query' => array(
     889                                array(
     890                                        'taxonomy' => 'category',
     891                                        'field' => 'id',
     892                                        'terms' => array( $cat_a ),
     893                                )
     894                        )
     895                ) );
     896
     897                $this->assertEquals( 4 , count( $posts ) );
     898
     899                $posts = get_posts( array(
     900                        'fields' => 'ids',
     901                        'update_post_meta_cache' => false,
     902                        'update_post_term_cache' => false,
     903                        'tax_query' => array(
     904                                array(
     905                                        'taxonomy' => 'category',
     906                                        'field' => 'id',
     907                                        'terms' => array( $cat_a ),
     908                                        'include_children' => false
     909                                )
     910                        )
     911                ) );
     912
     913                $this->assertEquals( 1 , count( $posts ) );
     914
     915                $posts = get_posts( array(
     916                        'fields' => 'ids',
     917                        'update_post_meta_cache' => false,
     918                        'update_post_term_cache' => false,
     919                        'tax_query' => array(
     920                                array(
     921                                        'taxonomy' => 'category',
     922                                        'field' => 'id',
     923                                        'terms' => array( $cat_b ),
     924                                )
     925                        )
     926                ) );
     927
     928                $this->assertEquals( 3 , count( $posts ) );
     929
     930                $posts = get_posts( array(
     931                        'fields' => 'ids',
     932                        'update_post_meta_cache' => false,
     933                        'update_post_term_cache' => false,
     934                        'tax_query' => array(
     935                                array(
     936                                        'taxonomy' => 'category',
     937                                        'field' => 'id',
     938                                        'terms' => array( $cat_b ),
     939                                        'include_children' => false
     940                                )
     941                        )
     942                ) );
     943
     944                $this->assertEquals( 1 , count( $posts ) );
     945
     946                $posts = get_posts( array(
     947                        'fields' => 'ids',
     948                        'update_post_meta_cache' => false,
     949                        'update_post_term_cache' => false,
     950                        'tax_query' => array(
     951                                array(
     952                                        'taxonomy' => 'category',
     953                                        'field' => 'id',
     954                                        'terms' => array( $cat_c ),
     955                                )
     956                        )
     957                ) );
     958
     959                $this->assertEquals( 1 , count( $posts ) );
     960
     961                $posts = get_posts( array(
     962                        'fields' => 'ids',
     963                        'update_post_meta_cache' => false,
     964                        'update_post_term_cache' => false,
     965                        'tax_query' => array(
     966                                array(
     967                                        'taxonomy' => 'category',
     968                                        'field' => 'id',
     969                                        'terms' => array( $cat_c ),
     970                                        'include_children' => false
     971                                )
     972                        )
     973                ) );
     974
     975                $this->assertEquals( 1 , count( $posts ) );
     976        }
     977
     978        public function test_tax_query_taxonomy_with_attachments() {
     979                $q = new WP_Query();
     980
     981                register_taxonomy_for_object_type( 'post_tag', 'attachment:image' );
     982                $tag_id = $this->factory->term->create( array( 'slug' => rand_str(), 'name' => rand_str() ) );
     983                $image_id = $this->factory->attachment->create_object( 'image.jpg', 0, array(
     984                        'post_mime_type' => 'image/jpeg',
     985                        'post_type' => 'attachment'
     986                ) );
     987                wp_set_object_terms( $image_id, $tag_id, 'post_tag' );
     988
     989                $posts = $q->query( array(
     990                        'fields' => 'ids',
     991                        'update_post_meta_cache' => false,
     992                        'update_post_term_cache' => false,
     993                        'post_type' => 'attachment',
     994                        'post_status' => 'inherit',
     995                        'tax_query' => array(
     996                                array(
     997                                        'taxonomy' => 'post_tag',
     998                                        'field' => 'term_id',
     999                                        'terms' => array( $tag_id )
     1000                                )
     1001                        )
     1002                ) );
     1003
     1004                $this->assertEquals( array( $image_id ), $posts );
     1005        }
     1006
     1007        public function test_tax_query_no_taxonomy() {
     1008                $cat_id = $this->factory->category->create( array( 'name' => 'alpha' ) );
     1009                $this->factory->post->create( array( 'post_title' => 'alpha', 'post_category' => array( $cat_id ) ) );
     1010
     1011                $response1 = new WP_Query( array(
     1012                        'tax_query' => array(
     1013                                array( 'terms' => array( $cat_id ) )
     1014                        )
     1015                ) );
     1016                $this->assertEmpty( $response1->posts );
     1017
     1018                $response2 = new WP_Query( array(
     1019                        'fields' => 'ids',
     1020                        'update_post_meta_cache' => false,
     1021                        'update_post_term_cache' => false,
     1022                        'tax_query' => array(
     1023                                array(
     1024                                        'taxonomy' => 'category',
     1025                                        'terms' => array( $cat_id )
     1026                                )
     1027                        )
     1028                ) );
     1029                $this->assertNotEmpty( $response2->posts );
     1030
     1031                $term = get_category( $cat_id );
     1032                $response3 = new WP_Query( array(
     1033                        'fields' => 'ids',
     1034                        'update_post_meta_cache' => false,
     1035                        'update_post_term_cache' => false,
     1036                        'tax_query' => array(
     1037                                array(
     1038                                        'field' => 'term_taxonomy_id',
     1039                                        'terms' => array( $term->term_taxonomy_id )
     1040                                )
     1041                        )
     1042                ) );
     1043                $this->assertNotEmpty( $response3->posts );
     1044        }
     1045
     1046        public function test_term_taxonomy_id_field_no_taxonomy() {
     1047                $q = new WP_Query();
     1048
     1049                $posts = $this->factory->post->create_many( 5 );
     1050
     1051                $cats = $tags = array();
     1052
     1053                // need term_taxonomy_ids in addition to term_ids, so no factory
     1054                for ( $i = 0; $i < 5; $i++ ) {
     1055                        $cats[$i] = wp_insert_term( 'category-' . $i , 'category' );
     1056                        $tags[$i] = wp_insert_term( 'tag-' . $i, 'post_tag' );
     1057
     1058                        // post 0 gets all terms
     1059                        wp_set_object_terms( $posts[0], array( $cats[$i]['term_id'] ), 'category', true );
     1060                        wp_set_object_terms( $posts[0], array( $tags[$i]['term_id'] ), 'post_tag', true );
     1061                }
     1062
     1063                wp_set_object_terms( $posts[1], array( $cats[0]['term_id'], $cats[2]['term_id'], $cats[4]['term_id'] ), 'category' );
     1064                wp_set_object_terms( $posts[1], array( $tags[0]['term_id'], $tags[2]['term_id'], $cats[4]['term_id'] ), 'post_tag' );
     1065
     1066                wp_set_object_terms( $posts[2], array( $cats[1]['term_id'], $cats[3]['term_id'] ), 'category' );
     1067                wp_set_object_terms( $posts[2], array( $tags[1]['term_id'], $tags[3]['term_id'] ), 'post_tag' );
     1068
     1069                wp_set_object_terms( $posts[3], array( $cats[0]['term_id'], $cats[2]['term_id'], $cats[4]['term_id'] ), 'category' );
     1070                wp_set_object_terms( $posts[3], array( $tags[1]['term_id'], $tags[3]['term_id'] ), 'post_tag' );
     1071
     1072                $results1 = $q->query( array(
     1073                        'fields' => 'ids',
     1074                        'update_post_meta_cache' => false,
     1075                        'update_post_term_cache' => false,
     1076                        'orderby' => 'ID',
     1077                        'order' => 'ASC',
     1078                        'tax_query' => array(
     1079                                'relation' => 'OR',
     1080                                array(
     1081                                        'field' => 'term_taxonomy_id',
     1082                                        'terms' => array( $cats[0]['term_taxonomy_id'], $cats[2]['term_taxonomy_id'], $cats[4]['term_taxonomy_id'], $tags[0]['term_taxonomy_id'], $tags[2]['term_taxonomy_id'], $cats[4]['term_taxonomy_id'] ),
     1083                                        'operator' => 'AND',
     1084                                        'include_children' => false,
     1085                                ),
     1086                                array(
     1087                                        'field' => 'term_taxonomy_id',
     1088                                        'terms' => array( $cats[1]['term_taxonomy_id'], $cats[3]['term_taxonomy_id'], $tags[1]['term_taxonomy_id'], $tags[3]['term_taxonomy_id'] ),
     1089                                        'operator' => 'AND',
     1090                                        'include_children' => false,
     1091                                )
     1092                        )
     1093                ) );
     1094
     1095                $this->assertEquals( array( $posts[0], $posts[1], $posts[2] ), $results1, 'Relation: OR; Operator: AND' );
     1096
     1097                $results2 = $q->query( array(
     1098                        'fields' => 'ids',
     1099                        'update_post_meta_cache' => false,
     1100                        'update_post_term_cache' => false,
     1101                        'orderby' => 'ID',
     1102                        'order' => 'ASC',
    2201103                        'tax_query' => array(
    2211104                                'relation' => 'AND',
    2221105                                array(
    223                                         'taxonomy' => 'testtax',
    224                                         'field' => 'slug',
    225                                         'terms' => array(
    226                                                 'tax-slug',
    227                                         ),
    228                                 ),
     1106                                        'field' => 'term_taxonomy_id',
     1107                                        'terms' => array( $cats[0]['term_taxonomy_id'], $tags[0]['term_taxonomy_id'] ),
     1108                                        'operator' => 'IN',
     1109                                        'include_children' => false,
     1110                                ),
     1111                                array(
     1112                                        'field' => 'term_taxonomy_id',
     1113                                        'terms' => array( $cats[3]['term_taxonomy_id'], $tags[3]['term_taxonomy_id'] ),
     1114                                        'operator' => 'IN',
     1115                                        'include_children' => false,
     1116                                )
    2291117                        )
    230                 );
    231 
    232                 $q = new WP_Query( $args );
    233                 $object = $q->get_queried_object();
    234 
    235                 $expected = get_term( $this->tax_id, 'testtax' );
    236 
    237                 // Only compare term_id because object_id may or may not be part of either value.
    238                 $this->assertEquals( $expected->term_id, $object->term_id );
     1118                ) );
     1119
     1120                $this->assertEquals( array( $posts[0], $posts[3] ), $results2, 'Relation: AND; Operator: IN' );
    2391121        }
    2401122
    2411123        /**
    242          * @group 30623
     1124         * @ticket 29738
    2431125         */
    244         public function test_get_queried_object_with_custom_taxonomy_tax_query_with_multiple_clauses_should_return_term_object_corresponding_to_the_first_queried_tax() {
    245                 // Don't override the args provided below.
    246                 remove_action( 'pre_get_posts', array( $this, 'pre_get_posts_tax_category_tax_query' ) );
    247 
    248                 register_taxonomy( 'testtax2', 'post' );
    249                 $testtax2_term_id = $this->factory->term->create( array(
    250                         'taxonomy' => 'testtax2',
    251                         'slug' => 'testtax2-slug',
    252                 ) );
    253 
    254                 $args = array(
    255                         'tax_query' => array(
    256                                 'relation' => 'AND',
    257                                 array(
    258                                         'taxonomy' => 'testtax',
    259                                         'field' => 'slug',
    260                                         'terms' => array(
    261                                                 'tax-slug',
    262                                         ),
    263                                 ),
    264                                 array(
    265                                         'taxonomy' => 'testtax2',
    266                                         'field' => 'slug',
    267                                         'terms' => array(
    268                                                 'testtax2-slug',
    269                                         ),
    270                                 ),
    271                         )
    272                 );
    273 
    274                 $q = new WP_Query( $args );
    275                 $object = $q->get_queried_object();
    276 
    277                 $expected = get_term( $this->tax_id, 'testtax' );
    278 
    279                 // Only compare term_id because object_id may or may not be part of either value.
    280                 $this->assertEquals( $expected->term_id, $object->term_id );
     1126        public function test_populate_taxonomy_query_var_from_tax_query() {
     1127                register_taxonomy( 'foo', 'post' );
     1128                $t = $this->factory->term->create( array(
     1129                        'taxonomy' => 'foo',
     1130                ) );
     1131                $c = $this->factory->term->create( array(
     1132                        'taxonomy' => 'category',
     1133                ) );
     1134
     1135                $q = new WP_Query( array(
     1136                        'tax_query' => array(
     1137                                // Empty terms mean that this one should be skipped
     1138                                array(
     1139                                        'taxonomy' => 'bar',
     1140                                        'terms' => array(),
     1141                                ),
     1142
     1143                                // Category and post tags should be skipped
     1144                                array(
     1145                                        'taxonomy' => 'category',
     1146                                        'terms' => array( $c ),
     1147                                ),
     1148
     1149                                array(
     1150                                        'taxonomy' => 'foo',
     1151                                        'terms' => array( $t ),
     1152                                ),
     1153                        ),
     1154                ) );
     1155
     1156                $this->assertSame( 'foo', $q->get( 'taxonomy' ) );
     1157
     1158                _unregister_taxonomy( 'foo' );
     1159        }
     1160
     1161        public function test_populate_taxonomy_query_var_from_tax_query_taxonomy_already_set() {
     1162                register_taxonomy( 'foo', 'post' );
     1163                register_taxonomy( 'foo1', 'post' );
     1164                $t = $this->factory->term->create( array(
     1165                        'taxonomy' => 'foo',
     1166                ) );
     1167
     1168                $q = new WP_Query( array(
     1169                        'taxonomy' => 'bar',
     1170                        'tax_query' => array(
     1171                                array(
     1172                                        'taxonomy' => 'foo',
     1173                                        'terms' => array( $t ),
     1174                                ),
     1175                        ),
     1176                ) );
     1177
     1178                $this->assertSame( 'bar', $q->get( 'taxonomy' ) );
     1179
     1180                _unregister_taxonomy( 'foo' );
     1181                _unregister_taxonomy( 'foo1' );
     1182        }
     1183
     1184        public function test_populate_term_query_var_from_tax_query() {
     1185                register_taxonomy( 'foo', 'post' );
     1186                $t = $this->factory->term->create( array(
     1187                        'taxonomy' => 'foo',
     1188                        'slug' => 'bar',
     1189                ) );
     1190
     1191                $q = new WP_Query( array(
     1192                        'tax_query' => array(
     1193                                array(
     1194                                        'taxonomy' => 'foo',
     1195                                        'terms' => array( 'bar' ),
     1196                                        'field' => 'slug',
     1197                                ),
     1198                        ),
     1199                ) );
     1200
     1201                $this->assertSame( 'bar', $q->get( 'term' ) );
     1202
     1203                _unregister_taxonomy( 'foo' );
     1204        }
     1205
     1206        public function test_populate_term_id_query_var_from_tax_query() {
     1207                register_taxonomy( 'foo', 'post' );
     1208                $t = $this->factory->term->create( array(
     1209                        'taxonomy' => 'foo',
     1210                        'slug' => 'bar',
     1211                ) );
     1212
     1213                $q = new WP_Query( array(
     1214                        'tax_query' => array(
     1215                                array(
     1216                                        'taxonomy' => 'foo',
     1217                                        'terms' => array( $t ),
     1218                                        'field' => 'term_id',
     1219                                ),
     1220                        ),
     1221                ) );
     1222
     1223                $this->assertEquals( $t, $q->get( 'term_id' ) );
     1224
     1225                _unregister_taxonomy( 'foo' );
     1226        }
     1227
     1228        /**
     1229         * @ticket 29738
     1230         */
     1231        public function test_populate_cat_category_name_query_var_from_tax_query() {
     1232                register_taxonomy( 'foo', 'post' );
     1233                $t = $this->factory->term->create( array(
     1234                        'taxonomy' => 'foo',
     1235                ) );
     1236                $c = $this->factory->term->create( array(
     1237                        'taxonomy' => 'category',
     1238                        'slug' => 'bar',
     1239                ) );
     1240
     1241                $q = new WP_Query( array(
     1242                        'tax_query' => array(
     1243                                // Non-category should be skipped
     1244                                array(
     1245                                        'taxonomy' => 'foo',
     1246                                        'terms' => array( $t ),
     1247                                ),
     1248
     1249                                // Empty terms mean that this one should be skipped
     1250                                array(
     1251                                        'taxonomy' => 'category',
     1252                                        'terms' => array(),
     1253                                ),
     1254
     1255                                // Category and post tags should be skipped
     1256                                array(
     1257                                        'taxonomy' => 'category',
     1258                                        'terms' => array( $c ),
     1259                                ),
     1260                        ),
     1261                ) );
     1262
     1263                $this->assertEquals( $c, $q->get( 'cat' ) );
     1264                $this->assertEquals( 'bar', $q->get( 'category_name' ) );
     1265
     1266                _unregister_taxonomy( 'foo' );
     1267        }
     1268
     1269        /**
     1270         * @ticket 29738
     1271         */
     1272        public function test_populate_tag_id_query_var_from_tax_query() {
     1273                register_taxonomy( 'foo', 'post' );
     1274                $t = $this->factory->term->create( array(
     1275                        'taxonomy' => 'foo',
     1276                ) );
     1277                $tag = $this->factory->term->create( array(
     1278                        'taxonomy' => 'post_tag',
     1279                        'slug' => 'bar',
     1280                ) );
     1281
     1282                $q = new WP_Query( array(
     1283                        'tax_query' => array(
     1284                                // Non-tag should be skipped
     1285                                array(
     1286                                        'taxonomy' => 'foo',
     1287                                        'terms' => array( $t ),
     1288                                ),
     1289
     1290                                // Empty terms mean that this one should be skipped
     1291                                array(
     1292                                        'taxonomy' => 'post_tag',
     1293                                        'terms' => array(),
     1294                                ),
     1295
     1296                                // Category and post tags should be skipped
     1297                                array(
     1298                                        'taxonomy' => 'post_tag',
     1299                                        'terms' => array( $tag ),
     1300                                ),
     1301                        ),
     1302                ) );
     1303
     1304                $this->assertEquals( $tag, $q->get( 'tag_id' ) );
     1305
     1306                _unregister_taxonomy( 'foo' );
    2811307        }
    2821308}
Note: See TracChangeset for help on using the changeset viewer.