Changeset 60676

Timestamp:

08/26/2025 10:22:12 PM (14 months ago)

Author:

davidbaumwald

Message:

Taxonomy: Ensure term_exists respects $parent_term when $term is an integer.

This change updates term_exists by ensuring that any numeric value passed as the $parent_term argument is passed to the subsequent get_terms call when the $term argument is an integer. This change includes unit tests to validate the fix.

Props spacedmonkey, lopo, lgadzhev, hugod, thehercules, nickbrazilian, audrasjb, vijendrajat, sachinrajcp123, bobbyleenoblestudios.
Fixes #55358.

Location:

trunk

Files:

• src/wp-includes/taxonomy.php (modified) (2 diffs)
• tests/phpunit/tests/term/termExists.php (modified) (1 diff)

trunk/src/wp-includes/taxonomy.php

@@ -1631 +1631 @@
         $defaults = apply_filters( 'term_exists_default_query_args', $defaults, $term, $taxonomy, $parent_term );
 
+        if ( ! empty( $taxonomy ) && is_numeric( $parent_term ) ) {
+                $defaults['parent'] = (int) $parent_term;
+        }
+
         if ( is_int( $term ) ) {
                 if ( 0 === $term ) {
@@ -1641 +1645 @@
                 if ( '' === $term ) {
                         return null;
-                }
-
-                if ( ! empty( $taxonomy ) && is_numeric( $parent_term ) ) {
-                        $defaults['parent'] = (int) $parent_term;
                 }
 

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

@@ -402 +402 @@
                 $this->assertNull( term_exists( null ) );
         }
+
+        /**
+         * @ticket 55358
+         * @covers ::term_exists()
+         */
+        public function test_term_exists_with_numeric_parent_term() {
+                register_taxonomy(
+                        'foo',
+                        'post',
+                        array(
+                                'hierarchical' => true,
+                        )
+                );
+
+                $parent_term = self::factory()->term->create(
+                        array(
+                                'taxonomy' => 'foo',
+                        )
+                );
+
+                $child_term = self::factory()->term->create(
+                        array(
+                                'taxonomy' => 'foo',
+                                'parent'   => $parent_term,
+                                'slug'     => 'child-term',
+                        )
+                );
+
+                // Test with numeric parent_term as integer
+                $found = term_exists( 'child-term', 'foo', $parent_term );
+                $this->assertIsArray( $found );
+                $this->assertEquals( $child_term, $found['term_id'] );
+
+                // Test with numeric parent_term as string
+                $found = term_exists( 'child-term', 'foo', (string) $parent_term );
+                $this->assertIsArray( $found );
+                $this->assertEquals( $child_term, $found['term_id'] );
+
+                _unregister_taxonomy( 'foo' );
+        }
+
+        /**
+         * @ticket 55358
+         * @covers ::term_exists()
+         */
+        public function test_term_exists_with_non_numeric_parent_term() {
+                register_taxonomy(
+                        'foo',
+                        'post',
+                        array(
+                                'hierarchical' => true,
+                        )
+                );
+
+                $parent_term = self::factory()->term->create(
+                        array(
+                                'taxonomy' => 'foo',
+                        )
+                );
+
+                $child_term = self::factory()->term->create(
+                        array(
+                                'taxonomy' => 'foo',
+                                'parent'   => $parent_term,
+                                'slug'     => 'child-term',
+                        )
+                );
+
+                // Test with non-numeric parent_term (should not set parent filter)
+                $found = term_exists( 'child-term', 'foo', 'not-numeric' );
+                $this->assertIsArray( $found );
+                $this->assertEquals( $child_term, $found['term_id'] );
+
+                // Test with null parent_term (should not set parent filter)
+                $found = term_exists( 'child-term', 'foo', null );
+                $this->assertIsArray( $found );
+                $this->assertEquals( $child_term, $found['term_id'] );
+
+                _unregister_taxonomy( 'foo' );
+        }
+
+        /**
+         * @ticket 55358
+         * @covers ::term_exists()
+         */
+        public function test_term_exists_with_empty_taxonomy_and_numeric_parent() {
+                register_taxonomy(
+                        'foo',
+                        'post',
+                        array(
+                                'hierarchical' => true,
+                        )
+                );
+
+                $parent_term = self::factory()->term->create(
+                        array(
+                                'taxonomy' => 'foo',
+                        )
+                );
+
+                $child_term = self::factory()->term->create(
+                        array(
+                                'taxonomy' => 'foo',
+                                'parent'   => $parent_term,
+                                'slug'     => 'child-term',
+                        )
+                );
+
+                // Test with empty taxonomy and numeric parent_term (should not set parent filter)
+                $found = term_exists( 'child-term', '', $parent_term );
+                $this->assertIsString( $found );
+                $this->assertEquals( $child_term, $found );
+
+                _unregister_taxonomy( 'foo' );
+        }
+
+        /**
+         * @ticket 55358
+         * @covers ::term_exists()
+         */
+        public function test_term_exists_with_wordpress_categories() {
+                // Create a parent category
+                $parent_cat = self::factory()->term->create(
+                        array(
+                                'taxonomy' => 'category',
+                                'name'     => 'Parent Category',
+                                'slug'     => 'parent-category',
+                        )
+                );
+
+                // Create a child category
+                $child_cat = self::factory()->term->create(
+                        array(
+                                'taxonomy' => 'category',
+                                'name'     => 'Child Category',
+                                'slug'     => 'child-category',
+                                'parent'   => $parent_cat,
+                        )
+                );
+
+                // Test finding child category with numeric parent
+                $found = term_exists( 'child-category', 'category', $parent_cat );
+                $this->assertIsArray( $found );
+                $this->assertEquals( $child_cat, $found['term_id'] );
+
+                // Test finding child category with wrong parent
+                $found = term_exists( 'child-category', 'category', 999 );
+                $this->assertNull( $found );
+        }
 }