WordPress.org

Make WordPress Core

Ticket #29859: 29859.2.patch

File 29859.2.patch, 13.3 KB (added by boonebgorges, 7 years ago)
  • src/wp-includes/taxonomy.php

    diff --git src/wp-includes/taxonomy.php src/wp-includes/taxonomy.php
    index 5846844..1b4902d 100644
    function get_terms( $taxonomies, $args = '' ) { 
    15121512                        $selects = array( 'COUNT(*)' );
    15131513                        break;
    15141514                case 'id=>name':
    1515                         $selects = array( 't.term_id', 't.name' );
     1515                        $selects = array( 't.term_id', 't.name', 'tt.count' );
    15161516                        break;
    15171517                case 'id=>slug':
    1518                         $selects = array( 't.term_id', 't.slug' );
     1518                        $selects = array( 't.term_id', 't.slug', 'tt.count' );
    15191519                        break;
    15201520        }
    15211521
  • tests/phpunit/tests/term/getTerms.php

    diff --git tests/phpunit/tests/term/getTerms.php tests/phpunit/tests/term/getTerms.php
    index bcc38a0..48a5ccd 100644
    class Tests_Term_getTerms extends WP_UnitTestCase { 
    351351
    352352                add_filter( 'wp_update_term_parent', 'wp_check_term_hierarchy_for_loops', 10, 3 );
    353353        }
     354
     355        /**
     356         * @ticket 29859
     357         */
     358        public function test_get_terms_hierarchical_tax_hide_empty_false_fields_ids() {
     359                // Set up a clean taxonomy.
     360                $tax = 'hierarchical_fields';
     361                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     362
     363                $terms = $this->create_hierarchical_terms_and_posts();
     364
     365                $found = get_terms( $tax, array(
     366                        'hide_empty' => false,
     367                        'fields' => 'ids',
     368                ) );
     369
     370                $expected = array(
     371                        $terms['parent1'],
     372                        $terms['parent2'],
     373                        $terms['child1'],
     374                        $terms['child2'],
     375                        $terms['grandchild1'],
     376                );
     377
     378                _unregister_taxonomy( 'hierarchical_fields' );
     379
     380                $this->assertEqualSets( $expected, $found );
     381        }
     382
     383        /**
     384         * @ticket 29859
     385         */
     386        public function test_get_terms_hierarchical_tax_hide_empty_true_fields_ids() {
     387                // Set up a clean taxonomy.
     388                $tax = 'hierarchical_fields';
     389                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     390
     391                $terms = $this->create_hierarchical_terms_and_posts();
     392
     393                $found = get_terms( $tax, array(
     394                        'hide_empty' => true,
     395                        'fields' => 'ids',
     396                ) );
     397
     398                $expected = array(
     399                        $terms['parent1'],
     400                        $terms['parent2'],
     401                        $terms['child1'],
     402                );
     403
     404                _unregister_taxonomy( 'hierarchical_fields' );
     405
     406                $this->assertEqualSets( $expected, $found );
     407        }
     408
     409        /**
     410         * @ticket 29859
     411         */
     412        public function test_get_terms_hierarchical_tax_hide_empty_true_fields_ids_hierarchical_false() {
     413                // Set up a clean taxonomy.
     414                $tax = 'hierarchical_fields';
     415                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     416
     417                $terms = $this->create_hierarchical_terms_and_posts();
     418
     419                $found = get_terms( $tax, array(
     420                        'hide_empty' => true,
     421                        'fields' => 'ids',
     422                        'hierarchical' => false,
     423                ) );
     424
     425                $expected = array(
     426                        $terms['parent2'],
     427                        $terms['child1'],
     428                );
     429
     430                _unregister_taxonomy( 'hierarchical_fields' );
     431
     432                $this->assertEqualSets( $expected, $found );
     433        }
     434
     435        /**
     436         * @ticket 29859
     437         */
     438        public function test_get_terms_hierarchical_tax_hide_empty_false_fields_names() {
     439                // Set up a clean taxonomy.
     440                $tax = 'hierarchical_fields';
     441                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     442
     443                $terms = $this->create_hierarchical_terms_and_posts();
     444
     445                $found = get_terms( $tax, array(
     446                        'hide_empty' => false,
     447                        'fields' => 'names',
     448                ) );
     449
     450                $expected = array(
     451                        'Parent 1',
     452                        'Parent 2',
     453                        'Child 1',
     454                        'Child 2',
     455                        'Grandchild 1',
     456                );
     457
     458                _unregister_taxonomy( 'hierarchical_fields' );
     459
     460                $this->assertEqualSets( $expected, $found );
     461        }
     462
     463        /**
     464         * @ticket 29859
     465         */
     466        public function test_get_terms_hierarchical_tax_hide_empty_true_fields_names() {
     467                // Set up a clean taxonomy.
     468                $tax = 'hierarchical_fields';
     469                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     470
     471                $terms = $this->create_hierarchical_terms_and_posts();
     472
     473                $found = get_terms( $tax, array(
     474                        'hide_empty' => true,
     475                        'fields' => 'names',
     476                ) );
     477
     478                $expected = array(
     479                        'Parent 1',
     480                        'Parent 2',
     481                        'Child 1',
     482                );
     483
     484                _unregister_taxonomy( 'hierarchical_fields' );
     485
     486                $this->assertEqualSets( $expected, $found );
     487        }
     488
     489        /**
     490         * @ticket 29859
     491         */
     492        public function test_get_terms_hierarchical_tax_hide_empty_true_fields_names_hierarchical_false() {
     493                // Set up a clean taxonomy.
     494                $tax = 'hierarchical_fields';
     495                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     496
     497                $terms = $this->create_hierarchical_terms_and_posts();
     498
     499                $found = get_terms( $tax, array(
     500                        'hide_empty' => true,
     501                        'fields' => 'names',
     502                        'hierarchical' => false,
     503                ) );
     504
     505                $expected = array(
     506                        'Parent 2',
     507                        'Child 1',
     508                );
     509
     510                _unregister_taxonomy( 'hierarchical_fields' );
     511
     512                $this->assertEqualSets( $expected, $found );
     513        }
     514
     515        /**
     516         * @ticket 29859
     517         */
     518        public function test_get_terms_hierarchical_tax_hide_empty_false_fields_count() {
     519                // Set up a clean taxonomy.
     520                $tax = 'hierarchical_fields';
     521                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     522
     523                $terms = $this->create_hierarchical_terms_and_posts();
     524
     525                $found = get_terms( $tax, array(
     526                        'hide_empty' => false,
     527                        'fields' => 'count',
     528                ) );
     529
     530                _unregister_taxonomy( 'hierarchical_fields' );
     531
     532                $this->assertEquals( 5, $found );
     533        }
     534
     535        /**
     536         * @ticket 29859
     537         */
     538        public function test_get_terms_hierarchical_tax_hide_empty_true_fields_count() {
     539                // Set up a clean taxonomy.
     540                $tax = 'hierarchical_fields';
     541                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     542
     543                $terms = $this->create_hierarchical_terms_and_posts();
     544
     545                $found = get_terms( $tax, array(
     546                        'hide_empty' => true,
     547                        'fields' => 'count',
     548                ) );
     549
     550                _unregister_taxonomy( 'hierarchical_fields' );
     551
     552                // When using 'fields=count', 'hierarchical' is forced to false.
     553                $this->assertEquals( 2, $found );
     554        }
     555
     556        /**
     557         * @ticket 29859
     558         */
     559        public function test_get_terms_hierarchical_tax_hide_empty_true_fields_count_hierarchical_false() {
     560                // Set up a clean taxonomy.
     561                $tax = 'hierarchical_fields';
     562                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     563
     564                $terms = $this->create_hierarchical_terms_and_posts();
     565
     566                $found = get_terms( $tax, array(
     567                        'hide_empty' => true,
     568                        'fields' => 'count',
     569                        'hierarchical' => false,
     570                ) );
     571
     572                _unregister_taxonomy( 'hierarchical_fields' );
     573
     574                $this->assertEquals( 2, $found );
     575        }
     576
     577        /**
     578         * @ticket 29859
     579         */
     580        public function test_get_terms_hierarchical_tax_hide_empty_false_fields_idparent() {
     581                // Set up a clean taxonomy.
     582                $tax = 'hierarchical_fields';
     583                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     584
     585                $terms = $this->create_hierarchical_terms_and_posts();
     586
     587                $found = get_terms( $tax, array(
     588                        'hide_empty' => false,
     589                        'fields' => 'id=>parent',
     590                ) );
     591
     592                $expected = array(
     593                        $terms['parent1'] => 0,
     594                        $terms['parent2'] => 0,
     595                        $terms['child1'] => $terms['parent1'],
     596                        $terms['child2'] => $terms['parent1'],
     597                        $terms['grandchild1'] => $terms['child1'],
     598                );
     599
     600                _unregister_taxonomy( 'hierarchical_fields' );
     601
     602                $this->assertEqualSets( $expected, $found );
     603        }
     604
     605        /**
     606         * @ticket 29859
     607         */
     608        public function test_get_terms_hierarchical_tax_hide_empty_true_fields_idparent() {
     609                // Set up a clean taxonomy.
     610                $tax = 'hierarchical_fields';
     611                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     612
     613                $terms = $this->create_hierarchical_terms_and_posts();
     614
     615                $found = get_terms( $tax, array(
     616                        'hide_empty' => true,
     617                        'fields' => 'id=>parent',
     618                ) );
     619
     620                $expected = array(
     621                        $terms['parent1'] => 0,
     622                        $terms['parent2'] => 0,
     623                        $terms['child1'] => $terms['parent1'],
     624                );
     625
     626                _unregister_taxonomy( 'hierarchical_fields' );
     627
     628                $this->assertEqualSets( $expected, $found );
     629        }
     630
     631        /**
     632         * @ticket 29859
     633         */
     634        public function test_get_terms_hierarchical_tax_hide_empty_true_fields_idparent_hierarchical_false() {
     635                // Set up a clean taxonomy.
     636                $tax = 'hierarchical_fields';
     637                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     638
     639                $terms = $this->create_hierarchical_terms_and_posts();
     640
     641                $found = get_terms( $tax, array(
     642                        'hide_empty' => true,
     643                        'fields' => 'id=>parent',
     644                        'hierarchical' => false,
     645                ) );
     646
     647                $expected = array(
     648                        $terms['parent2'] => 0,
     649                        $terms['child2'] => $terms['parent1'],
     650                );
     651
     652                _unregister_taxonomy( 'hierarchical_fields' );
     653
     654                $this->assertEqualSets( $expected, $found );
     655        }
     656
     657        /**
     658         * @ticket 29859
     659         */
     660        public function test_get_terms_hierarchical_tax_hide_empty_false_fields_idslug() {
     661                // Set up a clean taxonomy.
     662                $tax = 'hierarchical_fields';
     663                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     664
     665                $terms = $this->create_hierarchical_terms_and_posts();
     666
     667                $found = get_terms( $tax, array(
     668                        'hide_empty' => false,
     669                        'fields' => 'id=>slug',
     670                ) );
     671
     672                $expected = array(
     673                        $terms['parent1'] => 'parent-1',
     674                        $terms['parent2'] => 'parent-2',
     675                        $terms['child1'] => 'child-1',
     676                        $terms['child2'] => 'child-2',
     677                        $terms['grandchild1'] => 'grandchild-1',
     678                );
     679
     680                _unregister_taxonomy( 'hierarchical_fields' );
     681
     682                $this->assertEqualSets( $expected, $found );
     683        }
     684
     685        /**
     686         * @ticket 29859
     687         */
     688        public function test_get_terms_hierarchical_tax_hide_empty_true_fields_idslug() {
     689                // Set up a clean taxonomy.
     690                $tax = 'hierarchical_fields';
     691                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     692
     693                $terms = $this->create_hierarchical_terms_and_posts();
     694
     695                $found = get_terms( $tax, array(
     696                        'hide_empty' => true,
     697                        'fields' => 'id=>slug',
     698                ) );
     699
     700                $expected = array(
     701                        $terms['parent1'] => 'parent-1',
     702                        $terms['parent2'] => 'parent-2',
     703                        $terms['child1'] => 'child-1',
     704                );
     705
     706                _unregister_taxonomy( 'hierarchical_fields' );
     707
     708                $this->assertEqualSets( $expected, $found );
     709        }
     710
     711        /**
     712         * @ticket 29859
     713         */
     714        public function test_get_terms_hierarchical_tax_hide_empty_true_fields_idslug_hierarchical_false() {
     715                // Set up a clean taxonomy.
     716                $tax = 'hierarchical_fields';
     717                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     718
     719                $terms = $this->create_hierarchical_terms_and_posts();
     720
     721                $found = get_terms( $tax, array(
     722                        'hide_empty' => true,
     723                        'fields' => 'id=>slug',
     724                        'hierarchical' => false,
     725                ) );
     726
     727                $expected = array(
     728                        $terms['parent2'] => 'parent-2',
     729                        $terms['child1'] => 'child-1',
     730                );
     731
     732                _unregister_taxonomy( 'hierarchical_fields' );
     733
     734                $this->assertEqualSets( $expected, $found );
     735        }
     736
     737        /**
     738         * @ticket 29859
     739         */
     740        public function test_get_terms_hierarchical_tax_hide_empty_false_fields_idname() {
     741                // Set up a clean taxonomy.
     742                $tax = 'hierarchical_fields';
     743                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     744
     745                $terms = $this->create_hierarchical_terms_and_posts();
     746
     747                $found = get_terms( $tax, array(
     748                        'hide_empty' => false,
     749                        'fields' => 'id=>name',
     750                ) );
     751
     752                $expected = array(
     753                        $terms['parent1'] => 'Parent 1',
     754                        $terms['parent2'] => 'Parent 2',
     755                        $terms['child1'] => 'Child 1',
     756                        $terms['child2'] => 'Child 2',
     757                        $terms['grandchild1'] => 'Grandchild 1',
     758                );
     759
     760                _unregister_taxonomy( 'hierarchical_fields' );
     761
     762                $this->assertEqualSets( $expected, $found );
     763        }
     764
     765        /**
     766         * @ticket 29859
     767         */
     768        public function test_get_terms_hierarchical_tax_hide_empty_true_fields_idname() {
     769                // Set up a clean taxonomy.
     770                $tax = 'hierarchical_fields';
     771                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     772
     773                $terms = $this->create_hierarchical_terms_and_posts();
     774
     775                $found = get_terms( $tax, array(
     776                        'hide_empty' => true,
     777                        'fields' => 'id=>name',
     778                ) );
     779
     780                $expected = array(
     781                        $terms['parent1'] => 'Parent 1',
     782                        $terms['parent2'] => 'Parent 2',
     783                        $terms['child1'] => 'Child 1',
     784                );
     785
     786                _unregister_taxonomy( 'hierarchical_fields' );
     787
     788                $this->assertEqualSets( $expected, $found );
     789        }
     790
     791        /**
     792         * @ticket 29859
     793         */
     794        public function test_get_terms_hierarchical_tax_hide_empty_true_fields_idname_hierarchical_false() {
     795                // Set up a clean taxonomy.
     796                $tax = 'hierarchical_fields';
     797                register_taxonomy( $tax, 'post', array( 'hierarchical' => true ) );
     798
     799                $terms = $this->create_hierarchical_terms_and_posts();
     800
     801                $found = get_terms( $tax, array(
     802                        'hide_empty' => true,
     803                        'fields' => 'id=>name',
     804                        'hierarchical' => false,
     805                ) );
     806
     807                $expected = array(
     808                        $terms['parent2'] => 'Parent 2',
     809                        $terms['child1'] => 'Child 1',
     810                );
     811
     812                _unregister_taxonomy( 'hierarchical_fields' );
     813
     814                $this->assertEqualSets( $expected, $found );
     815        }
     816
     817        protected function create_hierarchical_terms_and_posts() {
     818
     819                $terms = array();
     820
     821                $terms['parent1'] = $this->factory->term->create( array( 'slug' => 'parent-1', 'name' => 'Parent 1', 'taxonomy' => 'hierarchical_fields' ) );
     822                $terms['parent2'] = $this->factory->term->create( array( 'slug' => 'parent-2', 'name' => 'Parent 2', 'taxonomy' => 'hierarchical_fields' ) );
     823                $terms['child1'] = $this->factory->term->create( array( 'slug' => 'child-1', 'name' => 'Child 1', 'taxonomy' => 'hierarchical_fields', 'parent' => $terms['parent1'] ) );
     824                $terms['child2'] = $this->factory->term->create( array( 'slug' => 'child-2', 'name' => 'Child 2', 'taxonomy' => 'hierarchical_fields', 'parent' => $terms['parent1'] ) );
     825                $terms['grandchild1'] = $this->factory->term->create( array( 'slug' => 'grandchild-1', 'name' => 'Grandchild 1', 'taxonomy' => 'hierarchical_fields', 'parent' => $terms['child1'] ) );
     826
     827                $post_id = $this->factory->post->create();
     828                wp_set_post_terms( $post_id, $terms['parent2'], 'hierarchical_fields', true );
     829                wp_set_post_terms( $post_id, $terms['child1'], 'hierarchical_fields', true );
     830
     831                return $terms;
     832        }
    354833}