WordPress.org
Get WordPress

Make WordPress Core

Changeset 55321


Ignore:
Timestamp:
02/13/2023 07:11:15 PM (4 years ago)
Author:
SergeyBiryukov
Message:

Tests: Move wp_comments_personal_data_exporter() tests to their own file.

This aims to make the tests more discoverable and easier to expand.

Follow-up to [42987], [55319].

See #56793.

Location:
trunk/tests/phpunit/tests
Files:
1 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/tests/phpunit/tests/comment.php

    r55320 r55321  
    12371237                $this->assertSame( '1', $comment->comment_approved );
    12381238        }
    1239 
    1240         /**
    1241          * Testing the `wp_comments_personal_data_exporter()` function.
    1242          *
    1243          * @group privacy
    1244          * @ticket 43440
    1245          *
    1246          * @covers ::wp_comments_personal_data_exporter
    1247          */
    1248         public function test_wp_comments_personal_data_exporter() {
    1249                 $args = array(
    1250                         'comment_post_ID'      => self::$post_id,
    1251                         'comment_author'       => 'Comment Author',
    1252                         'comment_author_email' => 'personal@local.host',
    1253                         'comment_author_url'   => 'https://local.host/',
    1254                         'comment_author_IP'    => '192.168.0.1',
    1255                         'comment_agent'        => 'SOME_AGENT',
    1256                         'comment_date'         => '2018-03-28 20:05:00',
    1257                         'comment_content'      => 'Comment',
    1258                 );
    1259 
    1260                 $comment_id = self::factory()->comment->create( $args );
    1261 
    1262                 $actual   = wp_comments_personal_data_exporter( $args['comment_author_email'] );
    1263                 $expected = $args;
    1264 
    1265                 $this->assertTrue( $actual['done'] );
    1266 
    1267                 // Number of exported comments.
    1268                 $this->assertCount( 1, $actual['data'] );
    1269 
    1270                 // Number of exported comment properties.
    1271                 $this->assertCount( 8, $actual['data'][0]['data'] );
    1272 
    1273                 // Exported group.
    1274                 $this->assertSame( 'comments', $actual['data'][0]['group_id'] );
    1275                 $this->assertSame( 'Comments', $actual['data'][0]['group_label'] );
    1276 
    1277                 // Exported comment properties.
    1278                 $this->assertSame( $expected['comment_author'], $actual['data'][0]['data'][0]['value'] );
    1279                 $this->assertSame( $expected['comment_author_email'], $actual['data'][0]['data'][1]['value'] );
    1280                 $this->assertSame( $expected['comment_author_url'], $actual['data'][0]['data'][2]['value'] );
    1281                 $this->assertSame( $expected['comment_author_IP'], $actual['data'][0]['data'][3]['value'] );
    1282                 $this->assertSame( $expected['comment_agent'], $actual['data'][0]['data'][4]['value'] );
    1283                 $this->assertSame( $expected['comment_date'], $actual['data'][0]['data'][5]['value'] );
    1284                 $this->assertSame( $expected['comment_content'], $actual['data'][0]['data'][6]['value'] );
    1285                 $this->assertSame( esc_html( get_comment_link( $comment_id ) ), strip_tags( $actual['data'][0]['data'][7]['value'] ) );
    1286         }
    1287 
    1288         /**
    1289          * Testing the `wp_comments_personal_data_exporter()` function for no comments found.
    1290          *
    1291          * @group privacy
    1292          * @ticket 43440
    1293          *
    1294          * @covers ::wp_comments_personal_data_exporter
    1295          */
    1296         public function test_wp_comments_personal_data_exporter_no_comments_found() {
    1297 
    1298                 $actual = wp_comments_personal_data_exporter( 'nocommentsfound@local.host' );
    1299 
    1300                 $expected = array(
    1301                         'data' => array(),
    1302                         'done' => true,
    1303                 );
    1304 
    1305                 $this->assertSame( $expected, $actual );
    1306         }
    1307 
    1308         /**
    1309          * Testing the `wp_comments_personal_data_exporter()` function for an empty comment property.
    1310          *
    1311          * @group privacy
    1312          * @ticket 43440
    1313          *
    1314          * @covers ::wp_comments_personal_data_exporter
    1315          */
    1316         public function test_wp_comments_personal_data_exporter_empty_comment_prop() {
    1317                 $args = array(
    1318                         'comment_post_ID'      => self::$post_id,
    1319                         'comment_author'       => 'Comment Author',
    1320                         'comment_author_email' => 'personal@local.host',
    1321                         'comment_author_url'   => 'https://local.host/',
    1322                         'comment_author_IP'    => '192.168.0.1',
    1323                         'comment_date'         => '2018-03-28 20:05:00',
    1324                         'comment_agent'        => '',
    1325                         'comment_content'      => 'Comment',
    1326                 );
    1327 
    1328                 $c = self::factory()->comment->create( $args );
    1329 
    1330                 $actual = wp_comments_personal_data_exporter( $args['comment_author_email'] );
    1331 
    1332                 $this->assertTrue( $actual['done'] );
    1333 
    1334                 // Number of exported comments.
    1335                 $this->assertCount( 1, $actual['data'] );
    1336 
    1337                 // Number of exported comment properties.
    1338                 $this->assertCount( 7, $actual['data'][0]['data'] );
    1339         }
    1340 
    1341         /**
    1342          * Testing the `wp_comments_personal_data_exporter()` function with an empty second page.
    1343          *
    1344          * @group privacy
    1345          * @ticket 43440
    1346          *
    1347          * @covers ::wp_comments_personal_data_exporter
    1348          */
    1349         public function test_wp_comments_personal_data_exporter_empty_second_page() {
    1350                 $args = array(
    1351                         'comment_post_ID'      => self::$post_id,
    1352                         'comment_author'       => 'Comment Author',
    1353                         'comment_author_email' => 'personal@local.host',
    1354                         'comment_author_url'   => 'https://local.host/',
    1355                         'comment_author_IP'    => '192.168.0.1',
    1356                         'comment_date'         => '2018-03-28 20:05:00',
    1357                         'comment_agent'        => 'SOME_AGENT',
    1358                         'comment_content'      => 'Comment',
    1359                 );
    1360 
    1361                 $c = self::factory()->comment->create( $args );
    1362 
    1363                 $actual = wp_comments_personal_data_exporter( $args['comment_author_email'], 2 );
    1364 
    1365                 $this->assertTrue( $actual['done'] );
    1366 
    1367                 // Number of exported comments.
    1368                 $this->assertCount( 0, $actual['data'] );
    1369         }
    13701239}

  • trunk/tests/phpunit/tests/comment/wpCommentsPersonalDataExporter.php

    r55320 r55321  
    33/**
    44 * @group comment
     5 * @group privacy
     6 *
     7 * @covers ::wp_comments_personal_data_exporter
    58 */
    6 class Tests_Comment extends WP_UnitTestCase {
    7         protected static $user_id;
    8         protected static $post_id;
    9         protected static $notify_message = '';
    10 
    11         protected $preprocess_comment_data = array();
    12 
    13         public function set_up() {
    14                 parent::set_up();
    15                 reset_phpmailer_instance();
    16         }
    17 
    18         public static function wpSetUpBeforeClass( WP_UnitTest_Factory $factory ) {
    19                 self::$user_id = $factory->user->create(
    20                         array(
    21                                 'role'       => 'author',
    22                                 'user_login' => 'test_wp_user_get',
    23                                 'user_pass'  => 'password',
    24                                 'user_email' => 'test@test.com',
    25                         )
    26                 );
    27 
    28                 self::$post_id = $factory->post->create(
    29                         array(
    30                                 'post_author' => self::$user_id,
    31                         )
    32                 );
    33         }
    34 
    35         /**
    36          * @covers ::wp_update_comment
    37          */
    38         public function test_wp_update_comment() {
    39                 $post  = self::factory()->post->create_and_get(
    40                         array(
    41                                 'post_title' => 'some-post',
    42                                 'post_type'  => 'post',
    43                         )
    44                 );
    45                 $post2 = self::factory()->post->create_and_get(
    46                         array(
    47                                 'post_title' => 'some-post-2',
    48                                 'post_type'  => 'post',
    49                         )
    50                 );
    51 
    52                 $comments = self::factory()->comment->create_post_comments( $post->ID, 5 );
    53 
    54                 $result = wp_update_comment(
    55                         array(
    56                                 'comment_ID'     => $comments[0],
    57                                 'comment_parent' => $comments[1],
    58                         )
    59                 );
    60                 $this->assertSame( 1, $result );
    61 
    62                 $comment = get_comment( $comments[0] );
    63                 $this->assertEquals( $comments[1], $comment->comment_parent );
    64 
    65                 $result = wp_update_comment(
    66                         array(
    67                                 'comment_ID'     => $comments[0],
    68                                 'comment_parent' => $comments[1],
    69                         )
    70                 );
    71                 $this->assertSame( 0, $result );
    72 
    73                 $result = wp_update_comment(
    74                         array(
    75                                 'comment_ID'      => $comments[0],
    76                                 'comment_post_ID' => $post2->ID,
    77                         )
    78                 );
    79 
    80                 $comment = get_comment( $comments[0] );
    81                 $this->assertEquals( $post2->ID, $comment->comment_post_ID );
    82         }
    83 
    84         public function test_update_comment_from_privileged_user_by_privileged_user() {
    85                 $admin_id_1 = self::factory()->user->create( array( 'role' => 'administrator' ) );
    86                 wp_set_current_user( $admin_id_1 );
    87 
    88                 $comment_id = wp_new_comment(
    89                         array(
    90                                 'comment_post_ID'      => self::$post_id,
    91                                 'comment_author'       => 'Author',
    92                                 'comment_author_url'   => 'http://example.localhost/',
    93                                 'comment_author_email' => 'test@test.com',
    94                                 'user_id'              => $admin_id_1,
    95                                 'comment_content'      => 'This is a comment',
    96                         )
    97                 );
    98 
    99                 wp_set_current_user( 0 );
    100 
    101                 $admin_id_2 = self::factory()->user->create(
    102                         array(
    103                                 'role'       => 'administrator',
    104                                 'user_login' => 'test_wp_admin_get',
    105                                 'user_pass'  => 'password',
    106                                 'user_email' => 'testadmin@test.com',
    107                         )
    108                 );
    109 
    110                 wp_set_current_user( $admin_id_2 );
    111 
    112                 wp_update_comment(
    113                         array(
    114                                 'comment_ID'      => $comment_id,
    115                                 'comment_content' => 'new comment <img onerror=demo src=x>',
    116                         )
    117                 );
    118 
    119                 $comment          = get_comment( $comment_id );
    120                 $expected_content = is_multisite()
    121                         ? 'new comment '
    122                         : 'new comment <img onerror=demo src=x>';
    123 
    124                 $this->assertSame( $expected_content, $comment->comment_content );
    125 
    126                 wp_set_current_user( 0 );
    127         }
    128 
    129         public function test_update_comment_from_unprivileged_user_by_privileged_user() {
    130                 wp_set_current_user( self::$user_id );
    131 
    132                 $comment_id = wp_new_comment(
    133                         array(
    134                                 'comment_post_ID'      => self::$post_id,
    135                                 'comment_author'       => 'Author',
    136                                 'comment_author_url'   => 'http://example.localhost/',
    137                                 'comment_author_email' => 'test@test.com',
    138                                 'user_id'              => self::$user_id,
    139                                 'comment_content'      => '<a href="http://example.localhost/something.html">click</a>',
    140                         )
    141                 );
    142 
    143                 wp_set_current_user( 0 );
    144 
    145                 $admin_id = self::factory()->user->create(
    146                         array(
    147                                 'role'       => 'administrator',
    148                                 'user_login' => 'test_wp_admin_get',
    149                                 'user_pass'  => 'password',
    150                                 'user_email' => 'testadmin@test.com',
    151                         )
    152                 );
    153 
    154                 wp_set_current_user( $admin_id );
    155 
    156                 wp_update_comment(
    157                         array(
    158                                 'comment_ID'      => $comment_id,
    159                                 'comment_content' => '<a href="http://example.localhost/something.html" disallowed=attribute>click</a>',
    160                         )
    161                 );
    162 
    163                 $comment = get_comment( $comment_id );
    164                 $this->assertEquals( '<a href="http://example.localhost/something.html" rel="nofollow ugc">click</a>', $comment->comment_content, 'Comment: ' . $comment->comment_content );
    165                 wp_set_current_user( 0 );
    166         }
    167 
    168         /**
    169          * @ticket 30627
    170          *
    171          * @covers ::wp_update_comment
    172          */
    173         public function test_wp_update_comment_updates_comment_type() {
    174                 $comment_id = self::factory()->comment->create( array( 'comment_post_ID' => self::$post_id ) );
    175 
    176                 wp_update_comment(
    177                         array(
    178                                 'comment_ID'   => $comment_id,
    179                                 'comment_type' => 'pingback',
    180                         )
    181                 );
    182 
    183                 $comment = get_comment( $comment_id );
    184                 $this->assertSame( 'pingback', $comment->comment_type );
    185         }
    186 
    187         /**
    188          * @ticket 36784
    189          *
    190          * @covers ::wp_update_comment
    191          */
    192         public function test_wp_update_comment_updates_comment_meta() {
    193                 $comment_id = self::factory()->comment->create( array( 'comment_post_ID' => self::$post_id ) );
    194 
    195                 wp_update_comment(
    196                         array(
    197                                 'comment_ID'   => $comment_id,
    198                                 'comment_meta' => array(
    199                                         'food'  => 'taco',
    200                                         'sauce' => 'fire',
    201                                 ),
    202                         )
    203                 );
    204 
    205                 $this->assertSame( 'fire', get_comment_meta( $comment_id, 'sauce', true ) );
    206         }
    207 
    208         /**
    209          * @ticket 30307
    210          *
    211          * @covers ::wp_update_comment
    212          */
    213         public function test_wp_update_comment_updates_user_id() {
    214                 $comment_id = self::factory()->comment->create( array( 'comment_post_ID' => self::$post_id ) );
    215 
    216                 wp_update_comment(
    217                         array(
    218                                 'comment_ID' => $comment_id,
    219                                 'user_id'    => 1,
    220                         )
    221                 );
    222 
    223                 $comment = get_comment( $comment_id );
    224                 $this->assertEquals( 1, $comment->user_id );
    225         }
    226 
    227         /**
    228          * @ticket 34954
    229          *
    230          * @covers ::wp_update_comment
    231          */
    232         public function test_wp_update_comment_with_no_post_id() {
    233                 $comment_id = self::factory()->comment->create( array( 'comment_post_ID' => 0 ) );
    234 
    235                 $updated_comment_text = 'I should be able to update a comment with a Post ID of zero';
    236 
    237                 $update = wp_update_comment(
    238                         array(
    239                                 'comment_ID'      => $comment_id,
    240                                 'comment_content' => $updated_comment_text,
    241                                 'comment_post_ID' => 0,
    242                         )
    243                 );
    244                 $this->assertSame( 1, $update );
    245 
    246                 $comment = get_comment( $comment_id );
    247                 $this->assertSame( $updated_comment_text, $comment->comment_content );
    248         }
    249 
    250         /**
    251          * @ticket 39732
    252          *
    253          * @covers ::wp_update_comment
    254          */
    255         public function test_wp_update_comment_returns_false_for_invalid_comment_or_post_id() {
    256                 $comment_id = self::factory()->comment->create( array( 'comment_post_ID' => self::$post_id ) );
    257 
    258                 $update = wp_update_comment(
    259                         array(
    260                                 'comment_ID'      => -1,
    261                                 'comment_post_ID' => self::$post_id,
    262                         )
    263                 );
    264                 $this->assertFalse( $update );
    265 
    266                 $update = wp_update_comment(
    267                         array(
    268                                 'comment_ID'      => $comment_id,
    269                                 'comment_post_ID' => -1,
    270                         )
    271                 );
    272                 $this->assertFalse( $update );
    273         }
    274 
    275         /**
    276          * @ticket 39732
    277          *
    278          * @covers ::wp_update_comment
    279          */
    280         public function test_wp_update_comment_is_wp_error() {
    281                 $comment_id = self::factory()->comment->create( array( 'comment_post_ID' => self::$post_id ) );
    282 
    283                 add_filter( 'wp_update_comment_data', array( $this, 'wp_update_comment_data_filter' ), 10, 3 );
    284 
    285                 $result = wp_update_comment(
    286                         array(
    287                                 'comment_ID'   => $comment_id,
    288                                 'comment_type' => 'pingback',
    289                         ),
    290                         true
    291                 );
    292 
    293                 remove_filter( 'wp_update_comment_data', array( $this, 'wp_update_comment_data_filter' ), 10, 3 );
    294 
    295                 $this->assertWPError( $result );
    296         }
    297 
    298         /**
    299          * Blocks comments from being updated by returning WP_Error.
    300          */
    301         public function wp_update_comment_data_filter( $data, $comment, $commentarr ) {
    302                 return new WP_Error( 'comment_wrong', 'wp_update_comment_data filter fails for this comment.', 500 );
    303         }
    304 
    305         /**
    306          * @covers ::get_approved_comments
    307          */
    308         public function test_get_approved_comments() {
    309                 $ca1 = self::factory()->comment->create(
    310                         array(
    311                                 'comment_post_ID'  => self::$post_id,
    312                                 'comment_approved' => '1',
    313                         )
    314                 );
    315                 $ca2 = self::factory()->comment->create(
    316                         array(
    317                                 'comment_post_ID'  => self::$post_id,
    318                                 'comment_approved' => '1',
    319                         )
    320                 );
    321                 $ca3 = self::factory()->comment->create(
    322                         array(
    323                                 'comment_post_ID'  => self::$post_id,
    324                                 'comment_approved' => '0',
    325                         )
    326                 );
    327                 $c2  = self::factory()->comment->create(
    328                         array(
    329                                 'comment_post_ID'  => self::$post_id,
    330                                 'comment_approved' => '1',
    331                                 'comment_type'     => 'pingback',
    332                         )
    333                 );
    334                 $c3  = self::factory()->comment->create(
    335                         array(
    336                                 'comment_post_ID'  => self::$post_id,
    337                                 'comment_approved' => '1',
    338                                 'comment_type'     => 'trackback',
    339                         )
    340                 );
    341                 $c4  = self::factory()->comment->create(
    342                         array(
    343                                 'comment_post_ID'  => self::$post_id,
    344                                 'comment_approved' => '1',
    345                                 'comment_type'     => 'mario',
    346                         )
    347                 );
    348                 $c5  = self::factory()->comment->create(
    349                         array(
    350                                 'comment_post_ID'  => self::$post_id,
    351                                 'comment_approved' => '1',
    352                                 'comment_type'     => 'luigi',
    353                         )
    354                 );
    355 
    356                 $found = get_approved_comments( self::$post_id );
    357 
    358                 // All comment types will be returned.
    359                 $this->assertEquals( array( $ca1, $ca2, $c2, $c3, $c4, $c5 ), wp_list_pluck( $found, 'comment_ID' ) );
    360         }
    361 
    362         /**
    363          * @ticket 30412
    364          *
    365          * @covers ::get_approved_comments
    366          */
    367         public function test_get_approved_comments_with_post_id_0_should_return_empty_array() {
    368                 $ca1 = self::factory()->comment->create(
    369                         array(
    370                                 'comment_post_ID'  => self::$post_id,
    371                                 'comment_approved' => '1',
    372                         )
    373                 );
    374 
    375                 $found = get_approved_comments( 0 );
    376 
    377                 $this->assertSame( array(), $found );
    378         }
    379 
    380         /**
    381          * @ticket 14279
    382          *
    383          * @covers ::wp_new_comment
    384          */
    385         public function test_wp_new_comment_respects_dates() {
    386                 $data = array(
    387                         'comment_post_ID'      => self::$post_id,
    388                         'comment_author'       => 'Comment Author',
    389                         'comment_author_url'   => '',
    390                         'comment_author_email' => '',
    391                         'comment_type'         => '',
    392                         'comment_content'      => 'Comment',
    393                         'comment_date'         => '2011-01-01 10:00:00',
    394                         'comment_date_gmt'     => '2011-01-01 10:00:00',
    395                 );
    396 
    397                 $id = wp_new_comment( $data );
    398 
    399                 $comment = get_comment( $id );
    400 
    401                 $this->assertSame( $data['comment_date'], $comment->comment_date );
    402                 $this->assertSame( $data['comment_date_gmt'], $comment->comment_date_gmt );
    403         }
    404 
    405         /**
    406          * @ticket 14601
    407          *
    408          * @covers ::wp_new_comment
    409          */
    410         public function test_wp_new_comment_respects_author_ip() {
    411                 $data = array(
    412                         'comment_post_ID'      => self::$post_id,
    413                         'comment_author'       => 'Comment Author',
    414                         'comment_author_IP'    => '192.168.1.1',
    415                         'comment_author_url'   => '',
    416                         'comment_author_email' => '',
    417                         'comment_type'         => '',
    418                         'comment_content'      => 'Comment',
    419                 );
    420 
    421                 $id = wp_new_comment( $data );
    422 
    423                 $comment = get_comment( $id );
    424 
    425                 $this->assertSame( $data['comment_author_IP'], $comment->comment_author_IP );
    426         }
    427 
    428         /**
    429          * @ticket 14601
    430          *
    431          * @covers ::wp_new_comment
    432          */
    433         public function test_wp_new_comment_respects_author_ip_empty_string() {
    434                 $data = array(
    435                         'comment_post_ID'      => self::$post_id,
    436                         'comment_author'       => 'Comment Author',
    437                         'comment_author_IP'    => '',
    438                         'comment_author_url'   => '',
    439                         'comment_author_email' => '',
    440                         'comment_type'         => '',
    441                         'comment_content'      => 'Comment',
    442                 );
    443 
    444                 $id = wp_new_comment( $data );
    445 
    446                 $comment = get_comment( $id );
    447 
    448                 $this->assertSame( $data['comment_author_IP'], $comment->comment_author_IP );
    449         }
    450 
    451         /**
    452          * @ticket 14601
    453          *
    454          * @covers ::wp_new_comment
    455          */
    456         public function test_wp_new_comment_respects_comment_agent() {
    457                 $data = array(
    458                         'comment_post_ID'      => self::$post_id,
    459                         'comment_author'       => 'Comment Author',
    460                         'comment_author_IP'    => '',
    461                         'comment_author_url'   => '',
    462                         'comment_author_email' => '',
    463                         'comment_agent'        => 'Mozilla/5.0 (iPhone; CPU iPhone OS 7_0 like Mac OS X; en-us) AppleWebKit/537.51.1 (KHTML, like Gecko) Version/7.0 Mobile/11A465 Safari/9537.53',
    464                         'comment_type'         => '',
    465                         'comment_content'      => 'Comment',
    466                 );
    467 
    468                 $id = wp_new_comment( $data );
    469 
    470                 $comment = get_comment( $id );
    471 
    472                 $this->assertSame( $data['comment_agent'], $comment->comment_agent );
    473         }
    474 
    475         /**
    476          * @ticket 14601
    477          *
    478          * @covers ::wp_new_comment
    479          */
    480         public function test_wp_new_comment_should_trim_provided_comment_agent_to_254_chars() {
    481                 $data = array(
    482                         'comment_post_ID'      => self::$post_id,
    483                         'comment_author'       => 'Comment Author',
    484                         'comment_author_IP'    => '',
    485                         'comment_author_url'   => '',
    486                         'comment_author_email' => '',
    487                         'comment_agent'        => 'Mozilla/5.0 (iPhone; CPU iPhone OS 7_0 like Mac OS X; en-us) AppleWebKit/537.51.1 (KHTML, like Gecko) Version/7.0 Mobile/11A465 Safari/9537.53 Opera/9.80 (X11; Linux i686; Ubuntu/14.10) Presto/2.12.388 Version/12.16 Mozilla/5.0 (Macintosh; U; PPC Mac OS X Mach-O; en; rv:1.8.1.4pre) Gecko/20070511 Camino/1.6pre',
    488                         'comment_type'         => '',
    489                         'comment_content'      => 'Comment',
    490                 );
    491 
    492                 $id = wp_new_comment( $data );
    493 
    494                 $comment = get_comment( $id );
    495 
    496                 $this->assertSame( 'Mozilla/5.0 (iPhone; CPU iPhone OS 7_0 like Mac OS X; en-us) AppleWebKit/537.51.1 (KHTML, like Gecko) Version/7.0 Mobile/11A465 Safari/9537.53 Opera/9.80 (X11; Linux i686; Ubuntu/14.10) Presto/2.12.388 Version/12.16 Mozilla/5.0 (Macintosh; U; PPC Mac OS ', $comment->comment_agent );
    497         }
    498 
    499         /**
    500          * @ticket 14601
    501          *
    502          * @covers ::wp_new_comment
    503          */
    504         public function test_wp_new_comment_respects_comment_agent_empty_string() {
    505                 $data = array(
    506                         'comment_post_ID'      => self::$post_id,
    507                         'comment_author'       => 'Comment Author',
    508                         'comment_author_IP'    => '',
    509                         'comment_author_url'   => '',
    510                         'comment_author_email' => '',
    511                         'comment_agent'        => '',
    512                         'comment_type'         => '',
    513                         'comment_content'      => 'Comment',
    514                 );
    515 
    516                 $id = wp_new_comment( $data );
    517 
    518                 $comment = get_comment( $id );
    519 
    520                 $this->assertSame( $data['comment_agent'], $comment->comment_agent );
    521         }
    522 
    523         /**
    524          * @covers ::wp_new_comment
    525          */
    526         public function test_wp_new_comment_respects_comment_field_lengths() {
    527                 $data = array(
    528                         'comment_post_ID'      => self::$post_id,
    529                         'comment_author'       => 'Comment Author',
    530                         'comment_author_url'   => '',
    531                         'comment_author_email' => '',
    532                         'comment_type'         => '',
    533                         'comment_content'      => str_repeat( 'A', 65536 ),
    534                         'comment_date'         => '2011-01-01 10:00:00',
    535                         'comment_date_gmt'     => '2011-01-01 10:00:00',
    536                 );
    537 
    538                 $id = wp_new_comment( $data );
    539 
    540                 $comment = get_comment( $id );
    541 
    542                 $this->assertSame( 65535, strlen( $comment->comment_content ) );
    543         }
    544 
    545         /**
    546          * @ticket 56244
    547          *
    548          * @covers ::wp_new_comment
    549          */
    550         public function test_wp_new_comment_sends_all_expected_parameters_to_preprocess_comment_filter() {
    551                 $user = get_userdata( self::$user_id );
    552                 wp_set_current_user( $user->ID );
    553 
    554                 $data = array(
    555                         'comment_post_ID'      => self::$post_id,
    556                         'comment_author'       => $user->display_name,
    557                         'comment_author_email' => $user->user_email,
    558                         'comment_author_url'   => $user->user_url,
    559                         'comment_content'      => 'Comment',
    560                         'comment_type'         => '',
    561                         'comment_parent'       => 0,
    562                         'user_id'              => $user->ID,
    563                 );
    564 
    565                 add_filter( 'preprocess_comment', array( $this, 'filter_preprocess_comment' ) );
    566 
    567                 $comment = wp_new_comment( $data );
    568 
    569                 $this->assertNotWPError( $comment );
    570                 $this->assertSameSetsWithIndex(
    571                         array(
    572                                 'comment_post_ID'      => self::$post_id,
    573                                 'comment_author'       => $user->display_name,
    574                                 'comment_author_email' => $user->user_email,
    575                                 'comment_author_url'   => $user->user_url,
    576                                 'comment_content'      => $data['comment_content'],
    577                                 'comment_type'         => '',
    578                                 'comment_parent'       => 0,
    579                                 'user_ID'              => $user->ID,
    580                                 'user_id'              => $user->ID,
    581                                 'comment_author_IP'    => '127.0.0.1',
    582                                 'comment_agent'        => '',
    583                         ),
    584                         $this->preprocess_comment_data
    585                 );
    586 
    587         }
    588 
    589         public function filter_preprocess_comment( $commentdata ) {
    590                 $this->preprocess_comment_data = $commentdata;
    591                 return $commentdata;
    592         }
    593 
    594         /**
    595          * @ticket 32566
    596          *
    597          * @covers ::wp_notify_moderator
    598          */
    599         public function test_wp_notify_moderator_should_not_throw_notice_when_post_author_is_0() {
    600                 $p = self::factory()->post->create(
    601                         array(
    602                                 'post_author' => 0,
    603                         )
    604                 );
    605 
    606                 $c = self::factory()->comment->create(
    607                         array(
    608                                 'comment_post_ID' => $p,
    609                         )
    610                 );
    611 
    612                 $this->assertTrue( wp_notify_moderator( $c ) );
    613         }
    614 
    615         /**
    616          * @covers ::wp_new_comment_notify_postauthor
    617          */
    618         public function test_wp_new_comment_notify_postauthor_should_send_email_when_comment_is_approved() {
    619                 $c = self::factory()->comment->create(
    620                         array(
    621                                 'comment_post_ID' => self::$post_id,
    622                         )
    623                 );
    624 
    625                 $sent = wp_new_comment_notify_postauthor( $c );
    626                 $this->assertTrue( $sent );
    627         }
    628 
    629         /**
    630          * @covers ::wp_new_comment_notify_postauthor
    631          */
    632         public function test_wp_new_comment_notify_postauthor_should_not_send_email_when_comment_is_unapproved() {
    633                 $c = self::factory()->comment->create(
    634                         array(
    635                                 'comment_post_ID'  => self::$post_id,
    636                                 'comment_approved' => '0',
    637                         )
    638                 );
    639 
    640                 $sent = wp_new_comment_notify_postauthor( $c );
    641                 $this->assertFalse( $sent );
    642         }
    643 
    644         /**
    645          * @ticket 33587
    646          *
    647          * @covers ::wp_new_comment_notify_postauthor
    648          */
    649         public function test_wp_new_comment_notify_postauthor_should_not_send_email_when_comment_has_been_marked_as_spam() {
    650                 $c = self::factory()->comment->create(
    651                         array(
    652                                 'comment_post_ID'  => self::$post_id,
    653                                 'comment_approved' => 'spam',
    654                         )
    655                 );
    656 
    657                 $sent = wp_new_comment_notify_postauthor( $c );
    658                 $this->assertFalse( $sent );
    659         }
    660 
    661         /**
    662          * @ticket 35006
    663          *
    664          * @covers ::wp_new_comment_notify_postauthor
    665          */
    666         public function test_wp_new_comment_notify_postauthor_should_not_send_email_when_comment_has_been_trashed() {
    667                 $c = self::factory()->comment->create(
    668                         array(
    669                                 'comment_post_ID'  => self::$post_id,
    670                                 'comment_approved' => 'trash',
    671                         )
    672                 );
    673 
    674                 $sent = wp_new_comment_notify_postauthor( $c );
    675                 $this->assertFalse( $sent );
    676         }
    677 
    678         /**
    679          * @ticket 43805
    680          *
    681          * @covers ::wp_new_comment_notify_postauthor
    682          */
    683         public function test_wp_new_comment_notify_postauthor_content_should_include_link_to_parent() {
    684                 $c1 = self::factory()->comment->create(
    685                         array(
    686                                 'comment_post_ID' => self::$post_id,
    687                         )
    688                 );
    689 
    690                 $c2 = self::factory()->comment->create(
    691                         array(
    692                                 'comment_post_ID' => self::$post_id,
    693                                 'comment_parent'  => $c1,
    694                         )
    695                 );
    696 
    697                 add_filter( 'comment_notification_text', array( $this, 'save_comment_notification_text' ) );
    698                 wp_new_comment_notify_postauthor( $c2 );
    699                 remove_filter( 'comment_notification_text', array( $this, 'save_comment_notification_text' ) );
    700 
    701                 $this->assertStringContainsString( admin_url( "comment.php?action=editcomment&c={$c1}" ), self::$notify_message );
    702         }
    703 
    704         /**
    705          * @ticket 43805
    706          *
    707          * @covers ::wp_new_comment_notify_moderator
    708          */
    709         public function test_wp_new_comment_notify_moderator_content_should_include_link_to_parent() {
    710                 $c1 = self::factory()->comment->create(
    711                         array(
    712                                 'comment_post_ID' => self::$post_id,
    713                         )
    714                 );
    715 
    716                 $c2 = self::factory()->comment->create(
    717                         array(
    718                                 'comment_post_ID'  => self::$post_id,
    719                                 'comment_parent'   => $c1,
    720                                 'comment_approved' => '0',
    721                         )
    722                 );
    723 
    724                 add_filter( 'comment_moderation_text', array( $this, 'save_comment_notification_text' ) );
    725                 wp_new_comment_notify_moderator( $c2 );
    726                 remove_filter( 'comment_moderation_text', array( $this, 'save_comment_notification_text' ) );
    727 
    728                 $this->assertStringContainsString( admin_url( "comment.php?action=editcomment&c={$c1}" ), self::$notify_message );
    729         }
    730 
    731         /**
    732          * Callback for the `comment_notification_text` & `comment_moderation_text` filters.
    733          *
    734          * @param string $notify_message The comment notification or moderation email text.
    735          * @return string
    736          */
    737         public function save_comment_notification_text( $notify_message = '' ) {
    738                 self::$notify_message = $notify_message;
    739                 return $notify_message;
    740         }
    741 
    742         /**
    743          * @ticket 12431
    744          *
    745          * @covers ::get_comment_meta
    746          */
    747         public function test_wp_new_comment_with_meta() {
    748                 $c = self::factory()->comment->create(
    749                         array(
    750                                 'comment_approved' => '1',
    751                                 'comment_meta'     => array(
    752                                         'food'  => 'taco',
    753                                         'sauce' => 'fire',
    754                                 ),
    755                         )
    756                 );
    757 
    758                 $this->assertSame( 'fire', get_comment_meta( $c, 'sauce', true ) );
    759         }
    760 
    761         /**
    762          * @ticket 8071
    763          *
    764          * @covers WP_Comment::get_children
    765          */
    766         public function test_wp_comment_get_children_should_fill_children() {
    767                 $c1 = self::factory()->comment->create(
    768                         array(
    769                                 'comment_post_ID'  => self::$post_id,
    770                                 'comment_approved' => '1',
    771                         )
    772                 );
    773 
    774                 $c2 = self::factory()->comment->create(
    775                         array(
    776                                 'comment_post_ID'  => self::$post_id,
    777                                 'comment_approved' => '1',
    778                                 'comment_parent'   => $c1,
    779                         )
    780                 );
    781 
    782                 $c3 = self::factory()->comment->create(
    783                         array(
    784                                 'comment_post_ID'  => self::$post_id,
    785                                 'comment_approved' => '1',
    786                                 'comment_parent'   => $c2,
    787                         )
    788                 );
    789 
    790                 $c4 = self::factory()->comment->create(
    791                         array(
    792                                 'comment_post_ID'  => self::$post_id,
    793                                 'comment_approved' => '1',
    794                                 'comment_parent'   => $c1,
    795                         )
    796                 );
    797 
    798                 $c5 = self::factory()->comment->create(
    799                         array(
    800                                 'comment_post_ID'  => self::$post_id,
    801                                 'comment_approved' => '1',
    802                         )
    803                 );
    804 
    805                 $c6 = self::factory()->comment->create(
    806                         array(
    807                                 'comment_post_ID'  => self::$post_id,
    808                                 'comment_approved' => '1',
    809                                 'comment_parent'   => $c5,
    810                         )
    811                 );
    812 
    813                 $comment  = get_comment( $c1 );
    814                 $children = $comment->get_children();
    815 
    816                 // Direct descendants of $c1.
    817                 $this->assertEqualSets( array( $c2, $c4 ), array_values( wp_list_pluck( $children, 'comment_ID' ) ) );
    818 
    819                 // Direct descendants of $c2.
    820                 $this->assertEqualSets( array( $c3 ), array_values( wp_list_pluck( $children[ $c2 ]->get_children(), 'comment_ID' ) ) );
    821         }
    822 
    823         /**
    824          * @ticket 27571
    825          *
    826          * @covers ::get_comment
    827          */
    828         public function test_post_properties_should_be_lazyloaded() {
    829                 $c = self::factory()->comment->create( array( 'comment_post_ID' => self::$post_id ) );
    830 
    831                 $post    = get_post( self::$post_id );
    832                 $comment = get_comment( $c );
    833 
    834                 $post_fields = array( 'post_author', 'post_date', 'post_date_gmt', 'post_content', 'post_title', 'post_excerpt', 'post_status', 'comment_status', 'ping_status', 'post_name', 'to_ping', 'pinged', 'post_modified', 'post_modified_gmt', 'post_content_filtered', 'post_parent', 'guid', 'menu_order', 'post_type', 'post_mime_type', 'comment_count' );
    835 
    836                 foreach ( $post_fields as $pf ) {
    837                         $this->assertTrue( isset( $comment->$pf ), $pf );
    838                         $this->assertSame( $post->$pf, $comment->$pf, $pf );
    839                 }
    840         }
    841 
    842 
    843         /**
    844          * Helper function to set up comment for 761 tests.
    845          *
    846          * @since 4.4.0
    847          * @access public
    848          */
    849         public function setup_notify_comment() {
    850                 /**
    851                  * Prevent flood alert from firing.
    852                  */
    853                 add_filter( 'comment_flood_filter', '__return_false' );
    854 
    855                 /**
    856                  * Set up a comment for testing.
    857                  */
    858                 $post = self::factory()->post->create(
    859                         array(
    860                                 'post_author' => self::$user_id,
    861                         )
    862                 );
    863 
    864                 $comment = self::factory()->comment->create(
    865                         array(
    866                                 'comment_post_ID' => $post,
    867                         )
    868                 );
    869 
    870                 return array(
    871                         'post'    => $post,
    872                         'comment' => $comment,
    873                 );
    874         }
    875 
    876         /**
    877          * @ticket 761
    878          *
    879          * @covers ::wp_new_comment
    880          */
    881         public function test_wp_notify_moderator_filter_moderation_notify_option_true_filter_false() {
    882                 $comment_data = $this->setup_notify_comment();
    883 
    884                 /**
    885                  * Test with moderator notification setting on, filter set to off.
    886                  * Should not send a notification.
    887                  */
    888                 update_option( 'moderation_notify', 1 );
    889                 add_filter( 'notify_moderator', '__return_false' );
    890 
    891                 $notification_sent = $this->try_sending_moderator_notification( $comment_data['comment'], $comment_data['post'] );
    892 
    893                 $this->assertFalse( $notification_sent, 'Moderator notification setting on, filter set to off' );
    894 
    895                 remove_filter( 'notify_moderator', '__return_false' );
    896                 remove_filter( 'comment_flood_filter', '__return_false' );
    897         }
    898 
    899         /**
    900          * @ticket 761
    901          *
    902          * @covers ::wp_new_comment
    903          */
    904         public function test_wp_notify_moderator_filter_moderation_notify_option_false_filter_true() {
    905                 $comment_data = $this->setup_notify_comment();
    906 
    907                 /**
    908                  * Test with moderator notification setting off, filter set to on.
    909                  * Should send a notification.
    910                  */
    911                 update_option( 'moderation_notify', 0 );
    912                 add_filter( 'notify_moderator', '__return_true' );
    913 
    914                 $notification_sent = $this->try_sending_moderator_notification( $comment_data['comment'], $comment_data['post'] );
    915 
    916                 $this->assertTrue( $notification_sent, 'Moderator notification setting off, filter set to on' );
    917 
    918                 remove_filter( 'notify_moderator', '__return_true' );
    919                 remove_filter( 'comment_flood_filter', '__return_false' );
    920         }
    921 
    922         /**
    923          * @ticket 761
    924          *
    925          * @covers ::wp_new_comment
    926          */
    927         public function test_wp_notify_post_author_filter_comments_notify_option_true_filter_false() {
    928 
    929                 $comment_data = $this->setup_notify_comment();
    930 
    931                 /**
    932                  * Test with author notification setting on, filter set to off.
    933                  * Should not send a notification.
    934                  */
    935                 update_option( 'comments_notify', 1 );
    936                 add_filter( 'notify_post_author', '__return_false' );
    937 
    938                 $notification_sent = $this->try_sending_author_notification( $comment_data['comment'], $comment_data['post'] );
    939 
    940                 $this->assertFalse( $notification_sent, 'Test with author notification setting on, filter set to off' );
    941 
    942                 remove_filter( 'notify_post_author', '__return_false' );
    943                 remove_filter( 'comment_flood_filter', '__return_false' );
    944         }
    945 
    946         /**
    947          * @ticket 761
    948          *
    949          * @covers ::wp_new_comment
    950          */
    951         public function test_wp_notify_post_author_filter_comments_notify_option_false_filter_true() {
    952                 $comment_data = $this->setup_notify_comment();
    953 
    954                 /**
    955                  * Test with author notification setting off, filter set to on.
    956                  * Should send a notification.
    957                  */
    958                 update_option( 'comments_notify', 0 );
    959                 add_filter( 'notify_post_author', '__return_true' );
    960 
    961                 $notification_sent = $this->try_sending_author_notification( $comment_data['comment'], $comment_data['post'] );
    962 
    963                 $this->assertTrue( $notification_sent, 'Test with author notification setting off, filter set to on' );
    964 
    965                 remove_filter( 'notify_post_author', '__return_true' );
    966                 remove_filter( 'comment_flood_filter', '__return_false' );
    967         }
    968 
    969         /**
    970          * Helper function to test moderator notifications.
    971          *
    972          * @since 4.4.0
    973          * @access public
    974          */
    975         public function try_sending_moderator_notification( $comment, $post ) {
    976 
    977                 // Don't approve comments, triggering notifications.
    978                 add_filter( 'pre_comment_approved', '__return_false' );
    979 
    980                 // Moderators are notified when a new comment is added.
    981                 $data = array(
    982                         'comment_post_ID'      => $post,
    983                         'comment_author'       => 'Comment Author',
    984                         'comment_author_url'   => '',
    985                         'comment_author_email' => '',
    986                         'comment_type'         => '',
    987                         'comment_content'      => 'Comment',
    988                 );
    989                 wp_new_comment( $data );
    990 
    991                 // Check to see if a notification email was sent to the moderator `admin@example.org`.
    992                 if ( isset( $GLOBALS['phpmailer']->mock_sent )
    993                         && ! empty( $GLOBALS['phpmailer']->mock_sent )
    994                         && WP_TESTS_EMAIL === $GLOBALS['phpmailer']->mock_sent[0]['to'][0][0]
    995                 ) {
    996                         $email_sent_when_comment_added = true;
    997                         reset_phpmailer_instance();
    998                 } else {
    999                         $email_sent_when_comment_added = false;
    1000                 }
    1001 
    1002                 return $email_sent_when_comment_added;
    1003         }
    1004 
    1005         /**
    1006          * Helper function to test sending author notifications.
    1007          *
    1008          * @since 4.4.0
    1009          * @access public
    1010          */
    1011         public function try_sending_author_notification( $comment, $post ) {
    1012 
    1013                 // Approve comments, triggering notifications.
    1014                 add_filter( 'pre_comment_approved', '__return_true' );
    1015 
    1016                 // Post authors possibly notified when a comment is approved on their post.
    1017                 wp_set_comment_status( $comment, 'approve' );
    1018 
    1019                 // Check to see if a notification email was sent to the post author `test@test.com`.
    1020                 if ( isset( $GLOBALS['phpmailer']->mock_sent )
    1021                         && ! empty( $GLOBALS['phpmailer']->mock_sent )
    1022                         && 'test@test.com' === $GLOBALS['phpmailer']->mock_sent[0]['to'][0][0]
    1023                 ) {
    1024                         $email_sent_when_comment_approved = true;
    1025                 } else {
    1026                         $email_sent_when_comment_approved = false;
    1027                 }
    1028                 reset_phpmailer_instance();
    1029 
    1030                 // Post authors are notified when a new comment is added to their post.
    1031                 $data = array(
    1032                         'comment_post_ID'      => $post,
    1033                         'comment_author'       => 'Comment Author',
    1034                         'comment_author_url'   => '',
    1035                         'comment_author_email' => '',
    1036                         'comment_type'         => '',
    1037                         'comment_content'      => 'Comment',
    1038                 );
    1039                 wp_new_comment( $data );
    1040 
    1041                 // Check to see if a notification email was sent to the post author `test@test.com`.
    1042                 if ( isset( $GLOBALS['phpmailer']->mock_sent ) &&
    1043                         ! empty( $GLOBALS['phpmailer']->mock_sent ) &&
    1044                         'test@test.com' === $GLOBALS['phpmailer']->mock_sent[0]['to'][0][0] ) {
    1045                                 $email_sent_when_comment_added = true;
    1046                                 reset_phpmailer_instance();
    1047                 } else {
    1048                         $email_sent_when_comment_added = false;
    1049                 }
    1050 
    1051                 return $email_sent_when_comment_approved || $email_sent_when_comment_added;
    1052         }
    1053 
    1054         /**
    1055          * @covers ::_close_comments_for_old_post
    1056          */
    1057         public function test_close_comments_for_old_post() {
    1058                 update_option( 'close_comments_for_old_posts', true );
    1059                 // Close comments more than one day old.
    1060                 update_option( 'close_comments_days_old', 1 );
    1061 
    1062                 $old_date    = date_create( '-25 hours' );
    1063                 $old_post_id = self::factory()->post->create( array( 'post_date' => date_format( $old_date, 'Y-m-d H:i:s' ) ) );
    1064 
    1065                 $old_post_comment_status = _close_comments_for_old_post( true, $old_post_id );
    1066                 $this->assertFalse( $old_post_comment_status );
    1067 
    1068                 $new_post_comment_status = _close_comments_for_old_post( true, self::$post_id );
    1069                 $this->assertTrue( $new_post_comment_status );
    1070         }
    1071 
    1072         /**
    1073          * @covers ::_close_comments_for_old_post
    1074          */
    1075         public function test_close_comments_for_old_post_undated_draft() {
    1076                 $draft_id             = self::factory()->post->create(
    1077                         array(
    1078                                 'post_status' => 'draft',
    1079                                 'post_type'   => 'post',
    1080                         )
    1081                 );
    1082                 $draft_comment_status = _close_comments_for_old_post( true, $draft_id );
    1083 
    1084                 $this->assertTrue( $draft_comment_status );
    1085         }
    1086 
    1087         /**
    1088          * @ticket 35276
    1089          *
    1090          * @covers ::wp_update_comment
    1091          */
    1092         public function test_wp_update_comment_author_id_and_agent() {
    1093 
    1094                 $default_data = array(
    1095                         'comment_post_ID'      => self::$post_id,
    1096                         'comment_author'       => 'Comment Author',
    1097                         'comment_author_IP'    => '192.168.0.1',
    1098                         'comment_agent'        => 'WRONG_AGENT',
    1099                         'comment_author_url'   => '',
    1100                         'comment_author_email' => '',
    1101                         'comment_type'         => '',
    1102                         'comment_content'      => 'Comment',
    1103                 );
    1104 
    1105                 $comment_id = wp_new_comment( $default_data );
    1106 
    1107                 // Confirm that the IP and Agent are correct on initial save.
    1108                 $save = get_comment( $comment_id );
    1109                 $this->assertSame( $default_data['comment_author_IP'], $save->comment_author_IP );
    1110                 $this->assertSame( $default_data['comment_agent'], $save->comment_agent );
    1111 
    1112                 // Update the comment.
    1113                 wp_update_comment(
    1114                         array(
    1115                                 'comment_ID'        => $comment_id,
    1116                                 'comment_author_IP' => '111.111.1.1',
    1117                                 'comment_agent'     => 'SHIELD_AGENT',
    1118                         )
    1119                 );
    1120 
    1121                 // Retrieve and check the new values.
    1122                 $updated = get_comment( $comment_id );
    1123                 $this->assertSame( '111.111.1.1', $updated->comment_author_IP );
    1124                 $this->assertSame( 'SHIELD_AGENT', $updated->comment_agent );
    1125         }
    1126 
    1127         /**
    1128          * @covers ::wp_get_comment_fields_max_lengths
    1129          */
    1130         public function test_wp_get_comment_fields_max_lengths() {
    1131                 $expected = array(
    1132                         'comment_author'       => 245,
    1133                         'comment_author_email' => 100,
    1134                         'comment_author_url'   => 200,
    1135                         'comment_content'      => 65525,
    1136                 );
    1137 
    1138                 $lengths = wp_get_comment_fields_max_lengths();
    1139 
    1140                 foreach ( $lengths as $field => $length ) {
    1141                         $this->assertSame( $expected[ $field ], $length );
    1142                 }
    1143         }
    1144 
    1145         /**
    1146          * @covers ::wp_update_comment
    1147          */
    1148         public function test_update_should_invalidate_comment_cache() {
    1149                 global $wpdb;
    1150 
    1151                 $c = self::factory()->comment->create( array( 'comment_author' => 'Foo' ) );
    1152 
    1153                 $comment = get_comment( $c );
    1154                 $this->assertSame( 'Foo', $comment->comment_author );
    1155 
    1156                 wp_update_comment(
    1157                         array(
    1158                                 'comment_ID'     => $c,
    1159                                 'comment_author' => 'Bar',
    1160                         )
    1161                 );
    1162 
    1163                 $comment = get_comment( $c );
    1164 
    1165                 $this->assertSame( 'Bar', $comment->comment_author );
    1166         }
    1167 
    1168         /**
    1169          * @covers ::wp_trash_comment
    1170          */
    1171         public function test_trash_should_invalidate_comment_cache() {
    1172                 global $wpdb;
    1173 
    1174                 $c = self::factory()->comment->create();
    1175 
    1176                 $comment = get_comment( $c );
    1177 
    1178                 wp_trash_comment( $c );
    1179 
    1180                 $comment = get_comment( $c );
    1181 
    1182                 $this->assertSame( 'trash', $comment->comment_approved );
    1183         }
    1184 
    1185         /**
    1186          * @covers ::wp_untrash_comment
    1187          */
    1188         public function test_untrash_should_invalidate_comment_cache() {
    1189                 global $wpdb;
    1190 
    1191                 $c = self::factory()->comment->create();
    1192                 wp_trash_comment( $c );
    1193 
    1194                 $comment = get_comment( $c );
    1195                 $this->assertSame( 'trash', $comment->comment_approved );
    1196 
    1197                 wp_untrash_comment( $c );
    1198 
    1199                 $comment = get_comment( $c );
    1200 
    1201                 $this->assertSame( '1', $comment->comment_approved );
    1202         }
    1203 
    1204         /**
    1205          * @covers ::wp_spam_comment
    1206          */
    1207         public function test_spam_should_invalidate_comment_cache() {
    1208                 global $wpdb;
    1209 
    1210                 $c = self::factory()->comment->create();
    1211 
    1212                 $comment = get_comment( $c );
    1213 
    1214                 wp_spam_comment( $c );
    1215 
    1216                 $comment = get_comment( $c );
    1217 
    1218                 $this->assertSame( 'spam', $comment->comment_approved );
    1219         }
    1220 
    1221         /**
    1222          * @covers ::wp_unspam_comment
    1223          */
    1224         public function test_unspam_should_invalidate_comment_cache() {
    1225                 global $wpdb;
    1226 
    1227                 $c = self::factory()->comment->create();
    1228                 wp_spam_comment( $c );
    1229 
    1230                 $comment = get_comment( $c );
    1231                 $this->assertSame( 'spam', $comment->comment_approved );
    1232 
    1233                 wp_unspam_comment( $c );
    1234 
    1235                 $comment = get_comment( $c );
    1236 
    1237                 $this->assertSame( '1', $comment->comment_approved );
    1238         }
     9class Tests_Comment_wpCommentsPersonalDataExporter extends WP_UnitTestCase {
    123910
    124011        /**
    124112         * Testing the `wp_comments_personal_data_exporter()` function.
    124213         *
    1243          * @group privacy
    124414         * @ticket 43440
    1245          *
    1246          * @covers ::wp_comments_personal_data_exporter
    124715         */
    124816        public function test_wp_comments_personal_data_exporter() {
    … …  
    128957         * Testing the `wp_comments_personal_data_exporter()` function for no comments found.
    129058         *
    1291          * @group privacy
    129259         * @ticket 43440
    1293          *
    1294          * @covers ::wp_comments_personal_data_exporter
    129560         */
    129661        public function test_wp_comments_personal_data_exporter_no_comments_found() {
    … …  
    130974         * Testing the `wp_comments_personal_data_exporter()` function for an empty comment property.
    131075         *
    1311          * @group privacy
    131276         * @ticket 43440
    1313          *
    1314          * @covers ::wp_comments_personal_data_exporter
    131577         */
    131678        public function test_wp_comments_personal_data_exporter_empty_comment_prop() {
    … …  
    1342104         * Testing the `wp_comments_personal_data_exporter()` function with an empty second page.
    1343105         *
    1344          * @group privacy
    1345106         * @ticket 43440
    1346          *
    1347          * @covers ::wp_comments_personal_data_exporter
    1348107         */
    1349108        public function test_wp_comments_personal_data_exporter_empty_second_page() {
Note: See TracChangeset for help on using the changeset viewer.