Changeset 61274 for branches/6.9

Timestamp:

11/20/2025 01:58:35 PM (10 months ago)

Author:

wildworks

Message:

Notes: trash (or delete) child notes when parent is deleted.

Ensure that when a top level note is trashed (or deleted), all of its replies (children) are also trashed or deleted. If EMPTY_TRASH_DAYS is 0, notes are deleted immediately; otherwise they are marked as trash for later cleanup.

Reviewed by wildworks.
Merges [61248] to the 6.9 branch.

Props adamsilverstein, desrosj, wildworks, mamaduka, karthickmurugan, jeffpaul, shailu25.
See #64240.

Location:

branches/6.9

Files:

• . (modified) (1 prop)
• src/wp-includes/comment.php (modified) (3 diffs)
• tests/phpunit/tests/comment.php (modified) (1 diff)

branches/6.9/src/wp-includes/comment.php

@@ -1575 +1575 @@
  *
  * @since 2.9.0
+ * @since 6.9.0 Any child notes are deleted when deleting a note.
  *
  * @param int|WP_Comment $comment_id Comment ID or WP_Comment object.
@@ -1581 +1582 @@
 function wp_trash_comment( $comment_id ) {
         if ( ! EMPTY_TRASH_DAYS ) {
-                return wp_delete_comment( $comment_id, true );
+                $comment = get_comment( $comment_id );
+                $success = wp_delete_comment( $comment_id, true );
+
+                if ( ! $success ) {
+                        return false;
+                }
+
+                // Also delete children of top level 'note' type comments.
+                if ( $comment && 'note' === $comment->comment_type && 0 === (int) $comment->comment_parent ) {
+                        $children = $comment->get_children(
+                                array(
+                                        'fields' => 'ids',
+                                        'status' => 'all',
+                                        'type'   => 'note',
+                                )
+                        );
+
+                        foreach ( $children as $child_id ) {
+                                if ( ! wp_delete_comment( $child_id, true ) ) {
+                                        $success = false;
+                                }
+                        }
+                }
+
+                return $success;
         }
 
@@ -1616 +1641 @@
                  */
                 do_action( 'trashed_comment', $comment->comment_ID, $comment );
+
+                // For top level 'note' type comments, also trash children.
+                if ( 'note' === $comment->comment_type && 0 === (int) $comment->comment_parent ) {
+                        $children = $comment->get_children(
+                                array(
+                                        'fields' => 'ids',
+                                        'status' => 'all',
+                                        'type'   => 'note',
+                                )
+                        );
+
+                        $success = true;
+                        foreach ( $children as $child_id ) {
+                                if ( ! wp_trash_comment( $child_id ) ) {
+                                        $success = false;
+                                }
+                        }
+                        return $success;
+                }
 
                 return true;

branches/6.9/tests/phpunit/tests/comment.php

@@ -1673 +1673 @@
                 $this->assertSame( '1', $comment->comment_approved );
         }
+
+        /**
+         * Tests that trashing a top-level note also trashes all direct child notes.
+         *
+         * @ticket 64240
+         * @covers ::wp_trash_comment
+         * @dataProvider data_comment_approved_statuses
+         */
+        public function test_wp_trash_comment_trashes_child_notes( $approved_status ) {
+                // Create a parent note (top-level, comment_parent=0).
+                $parent_note = self::factory()->comment->create(
+                        array(
+                                'comment_post_ID'  => self::$post_id,
+                                'comment_type'     => 'note',
+                                'comment_parent'   => 0,
+                                'comment_approved' => $approved_status,
+                        )
+                );
+
+                // Create child notes under the parent.
+                $child_note_1 = self::factory()->comment->create(
+                        array(
+                                'comment_post_ID'  => self::$post_id,
+                                'comment_type'     => 'note',
+                                'comment_parent'   => $parent_note,
+                                'comment_approved' => $approved_status,
+                        )
+                );
+
+                $child_note_2 = self::factory()->comment->create(
+                        array(
+                                'comment_post_ID'  => self::$post_id,
+                                'comment_type'     => 'note',
+                                'comment_parent'   => $parent_note,
+                                'comment_approved' => $approved_status,
+                        )
+                );
+
+                $child_note_3 = self::factory()->comment->create(
+                        array(
+                                'comment_post_ID'  => self::$post_id,
+                                'comment_type'     => 'note',
+                                'comment_parent'   => $parent_note,
+                                'comment_approved' => $approved_status,
+                        )
+                );
+
+                // Trash the parent note.
+                wp_trash_comment( $parent_note );
+
+                // Verify parent note is trashed.
+                $this->assertSame( 'trash', get_comment( $parent_note )->comment_approved );
+
+                // Verify all child notes are also trashed.
+                $this->assertSame( 'trash', get_comment( $child_note_1 )->comment_approved );
+                $this->assertSame( 'trash', get_comment( $child_note_2 )->comment_approved );
+                $this->assertSame( 'trash', get_comment( $child_note_3 )->comment_approved );
+        }
+
+        /**
+         * Data provider for test_wp_trash_comment_trashes_child_notes.
+         */
+        public function data_comment_approved_statuses() {
+                return array(
+                        array( '1' ),
+                        array( '0' ),
+                );
+        }
+
+        /**
+         * Tests that trashing a regular comment does NOT trash its children.
+         *
+         * @ticket 64240
+         * @covers ::wp_trash_comment
+         */
+        public function test_wp_trash_comment_does_not_trash_child_comments() {
+                // Create a parent comment (default type='comment').
+                $parent_comment = self::factory()->comment->create(
+                        array(
+                                'comment_post_ID'  => self::$post_id,
+                                'comment_type'     => 'comment',
+                                'comment_parent'   => 0,
+                                'comment_approved' => '1',
+                        )
+                );
+
+                // Create child comments under the parent.
+                $child_comment_1 = self::factory()->comment->create(
+                        array(
+                                'comment_post_ID'  => self::$post_id,
+                                'comment_type'     => 'comment',
+                                'comment_parent'   => $parent_comment,
+                                'comment_approved' => '1',
+                        )
+                );
+
+                $child_comment_2 = self::factory()->comment->create(
+                        array(
+                                'comment_post_ID'  => self::$post_id,
+                                'comment_type'     => 'comment',
+                                'comment_parent'   => $parent_comment,
+                                'comment_approved' => '1',
+                        )
+                );
+
+                // Trash the parent comment.
+                wp_trash_comment( $parent_comment );
+
+                // Verify parent comment is trashed.
+                $this->assertSame( 'trash', get_comment( $parent_comment )->comment_approved );
+
+                // Verify child comments are NOT trashed (maintaining existing behavior).
+                $this->assertSame( '1', get_comment( $child_comment_1 )->comment_approved );
+                $this->assertSame( '1', get_comment( $child_comment_2 )->comment_approved );
+        }
+
+        /**
+         * Tests that trashing a child note does not affect parent or siblings.
+         *
+         * @ticket 64240
+         * @covers ::wp_trash_comment
+         */
+        public function test_wp_trash_comment_child_note_does_not_affect_parent_or_siblings() {
+                // Create a parent note.
+                $parent_note = self::factory()->comment->create(
+                        array(
+                                'comment_post_ID'  => self::$post_id,
+                                'comment_type'     => 'note',
+                                'comment_parent'   => 0,
+                                'comment_approved' => '1',
+                        )
+                );
+
+                // Create multiple child notes.
+                $child_note_1 = self::factory()->comment->create(
+                        array(
+                                'comment_post_ID'  => self::$post_id,
+                                'comment_type'     => 'note',
+                                'comment_parent'   => $parent_note,
+                                'comment_approved' => '1',
+                        )
+                );
+
+                $child_note_2 = self::factory()->comment->create(
+                        array(
+                                'comment_post_ID'  => self::$post_id,
+                                'comment_type'     => 'note',
+                                'comment_parent'   => $parent_note,
+                                'comment_approved' => '1',
+                        )
+                );
+
+                $child_note_3 = self::factory()->comment->create(
+                        array(
+                                'comment_post_ID'  => self::$post_id,
+                                'comment_type'     => 'note',
+                                'comment_parent'   => $parent_note,
+                                'comment_approved' => '1',
+                        )
+                );
+
+                // Trash only one child note.
+                wp_trash_comment( $child_note_2 );
+
+                // Verify the parent note is still approved.
+                $this->assertSame( '1', get_comment( $parent_note )->comment_approved );
+
+                // Verify the trashed child is trashed.
+                $this->assertSame( 'trash', get_comment( $child_note_2 )->comment_approved );
+
+                // Verify sibling notes are still approved.
+                $this->assertSame( '1', get_comment( $child_note_1 )->comment_approved );
+                $this->assertSame( '1', get_comment( $child_note_3 )->comment_approved );
+        }
+
+        /**
+         * Tests that only top-level notes trigger child deletion.
+         *
+         * @ticket 64240
+         * @covers ::wp_trash_comment
+         */
+        public function test_wp_trash_comment_only_top_level_notes_trigger_child_deletion() {
+                // Create a parent note.
+                $parent_note = self::factory()->comment->create(
+                        array(
+                                'comment_post_ID'  => self::$post_id,
+                                'comment_type'     => 'note',
+                                'comment_parent'   => 0,
+                                'comment_approved' => '1',
+                        )
+                );
+
+                // Create a child note (not top-level, has comment_parent > 0).
+                $child_note = self::factory()->comment->create(
+                        array(
+                                'comment_post_ID'  => self::$post_id,
+                                'comment_type'     => 'note',
+                                'comment_parent'   => $parent_note,
+                                'comment_approved' => '1',
+                        )
+                );
+
+                // Create a sibling note (also not top-level).
+                $sibling_note = self::factory()->comment->create(
+                        array(
+                                'comment_post_ID'  => self::$post_id,
+                                'comment_type'     => 'note',
+                                'comment_parent'   => $parent_note,
+                                'comment_approved' => '1',
+                        )
+                );
+
+                // Trash the child note (which has comment_parent > 0).
+                wp_trash_comment( $child_note );
+
+                // Verify the child note is trashed.
+                $this->assertSame( 'trash', get_comment( $child_note )->comment_approved );
+
+                // Verify the parent note is NOT trashed.
+                $this->assertSame( '1', get_comment( $parent_note )->comment_approved );
+
+                // Verify the sibling note is NOT trashed (no cascade since child is not top-level).
+                $this->assertSame( '1', get_comment( $sibling_note )->comment_approved );
+        }
 }