WordPress.org
Get WordPress

Make WordPress Core


Ignore:
Timestamp:
11/30/2017 11:09:33 PM (9 years ago)
Author:
pento
Message:

Code is Poetry.
WordPress' code just... wasn't.
This is now dealt with.

Props jrf, pento, netweb, GaryJ, jdgrimes, westonruter, Greg Sherwood from PHPCS, and everyone who's ever contributed to WPCS and PHPCS.
Fixes #41057.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/tests/phpunit/tests/post.php

    r40816 r42343  
    1313                self::$editor_id = $factory->user->create( array( 'role' => 'editor' ) );
    1414
    15                 add_role( 'grammarian', 'Grammarian', array(
    16                         'read'                 => true,
    17                         'edit_posts'           => true,
    18                         'edit_others_posts'    => true,
    19                         'edit_published_posts' => true,
    20                 ) );
     15                add_role(
     16                        'grammarian', 'Grammarian', array(
     17                                'read'                 => true,
     18                                'edit_posts'           => true,
     19                                'edit_others_posts'    => true,
     20                                'edit_published_posts' => true,
     21                        )
     22                );
    2123
    2224                self::$grammarian_id = $factory->user->create( array( 'role' => 'grammarian' ) );
    … …  
    3739
    3840        // helper function: return the timestamp(s) of cron jobs for the specified hook and post
    39         function _next_schedule_for_post($hook, $id) {
    40                 return wp_next_scheduled('publish_future_post', array(0=>intval($id)));
     41        function _next_schedule_for_post( $hook, $id ) {
     42                return wp_next_scheduled( 'publish_future_post', array( 0 => intval( $id ) ) );
    4143        }
    4244
    … …  
    5658                foreach ( $post_types as $post_type ) {
    5759                        $post = array(
    58                                 'post_author' => self::$editor_id,
    59                                 'post_status' => 'publish',
     60                                'post_author'  => self::$editor_id,
     61                                'post_status'  => 'publish',
    6062                                'post_content' => rand_str(),
    61                                 'post_title' => rand_str(),
    62                                 'tax_input' => array( 'post_tag' => 'tag1,tag2', 'ctax' => 'cterm1,cterm2' ),
    63                                 'post_type' => $post_type
     63                                'post_title'   => rand_str(),
     64                                'tax_input'    => array(
     65                                        'post_tag' => 'tag1,tag2',
     66                                        'ctax'     => 'cterm1,cterm2',
     67                                ),
     68                                'post_type'    => $post_type,
    6469                        );
    6570
    6671                        // insert a post and make sure the ID is ok
    67                         $id = wp_insert_post($post);
    68                         $this->assertTrue(is_numeric($id));
    69                         $this->assertTrue($id > 0);
     72                        $id = wp_insert_post( $post );
     73                        $this->assertTrue( is_numeric( $id ) );
     74                        $this->assertTrue( $id > 0 );
    7075
    7176                        // fetch the post and make sure it matches
    72                         $out = get_post($id);
    73 
    74                         $this->assertEquals($post['post_content'], $out->post_content);
    75                         $this->assertEquals($post['post_title'], $out->post_title);
    76                         $this->assertEquals($post['post_status'], $out->post_status);
    77                         $this->assertEquals($post['post_author'], $out->post_author);
     77                        $out = get_post( $id );
     78
     79                        $this->assertEquals( $post['post_content'], $out->post_content );
     80                        $this->assertEquals( $post['post_title'], $out->post_title );
     81                        $this->assertEquals( $post['post_status'], $out->post_status );
     82                        $this->assertEquals( $post['post_author'], $out->post_author );
    7883
    7984                        // test cache state
    … …  
    8388
    8489                        update_object_term_cache( $id, $post_type );
    85                         $tcache = wp_cache_get( $id, "post_tag_relationships" );
     90                        $tcache = wp_cache_get( $id, 'post_tag_relationships' );
    8691                        $this->assertInternalType( 'array', $tcache );
    8792                        $this->assertEquals( 2, count( $tcache ) );
    8893
    89                         $tcache = wp_cache_get( $id, "ctax_relationships" );
     94                        $tcache = wp_cache_get( $id, 'ctax_relationships' );
    9095                        if ( 'cpt' == $post_type ) {
    9196                                $this->assertInternalType( 'array', $tcache );
    … …  
    97102                        wp_delete_post( $id, true );
    98103                        $this->assertFalse( wp_cache_get( $id, 'posts' ) );
    99                         $this->assertFalse( wp_cache_get( $id, "post_tag_relationships" ) );
    100                         $this->assertFalse( wp_cache_get( $id, "ctax_relationships" ) );
     104                        $this->assertFalse( wp_cache_get( $id, 'post_tag_relationships' ) );
     105                        $this->assertFalse( wp_cache_get( $id, 'ctax_relationships' ) );
    101106                }
    102107
    … …  
    107112                // insert a post with a future date, and make sure the status and cron schedule are correct
    108113
    109                 $future_date = strtotime('+1 day');
     114                $future_date = strtotime( '+1 day' );
    110115
    111116                $post = array(
    112                         'post_author' => self::$editor_id,
    113                         'post_status' => 'publish',
     117                        'post_author'  => self::$editor_id,
     118                        'post_status'  => 'publish',
    114119                        'post_content' => rand_str(),
    115                         'post_title' => rand_str(),
    116                         'post_date'  => strftime("%Y-%m-%d %H:%M:%S", $future_date),
     120                        'post_title'   => rand_str(),
     121                        'post_date'    => strftime( '%Y-%m-%d %H:%M:%S', $future_date ),
    117122                );
    118123
    119124                // insert a post and make sure the ID is ok
    120                 $id = $this->post_ids[] = wp_insert_post($post);
     125                $id = $this->post_ids[] = wp_insert_post( $post );
    121126                #dmp(_get_cron_array());
    122                 $this->assertTrue(is_numeric($id));
    123                 $this->assertTrue($id > 0);
     127                $this->assertTrue( is_numeric( $id ) );
     128                $this->assertTrue( $id > 0 );
    124129
    125130                // fetch the post and make sure it matches
    126                 $out = get_post($id);
    127 
    128                 $this->assertEquals($post['post_content'], $out->post_content);
    129                 $this->assertEquals($post['post_title'], $out->post_title);
    130                 $this->assertEquals('future', $out->post_status);
    131                 $this->assertEquals($post['post_author'], $out->post_author);
    132                 $this->assertEquals($post['post_date'], $out->post_date);
     131                $out = get_post( $id );
     132
     133                $this->assertEquals( $post['post_content'], $out->post_content );
     134                $this->assertEquals( $post['post_title'], $out->post_title );
     135                $this->assertEquals( 'future', $out->post_status );
     136                $this->assertEquals( $post['post_author'], $out->post_author );
     137                $this->assertEquals( $post['post_date'], $out->post_date );
    133138
    134139                // there should be a publish_future_post hook scheduled on the future date
    135                 $this->assertEquals($future_date, $this->_next_schedule_for_post('publish_future_post', $id));
     140                $this->assertEquals( $future_date, $this->_next_schedule_for_post( 'publish_future_post', $id ) );
    136141        }
    137142
    … …  
    140145
    141146                // Some magic days - one dst one not
    142                 $future_date_1 = strtotime('June 21st +1 year');
    143                 $future_date_2 = strtotime('Jan 11th +1 year');
    144 
     147                $future_date_1 = strtotime( 'June 21st +1 year' );
     148                $future_date_2 = strtotime( 'Jan 11th +1 year' );
    145149
    146150                $post = array(
    147                         'post_author' => self::$editor_id,
    148                         'post_status' => 'publish',
     151                        'post_author'  => self::$editor_id,
     152                        'post_status'  => 'publish',
    149153                        'post_content' => rand_str(),
    150                         'post_title' => rand_str(),
    151                         'post_date'  => strftime("%Y-%m-%d %H:%M:%S", $future_date_1),
     154                        'post_title'   => rand_str(),
     155                        'post_date'    => strftime( '%Y-%m-%d %H:%M:%S', $future_date_1 ),
    152156                );
    153157
    154158                // insert a post and make sure the ID is ok
    155                 $id = $this->post_ids[] = wp_insert_post($post);
     159                $id = $this->post_ids[] = wp_insert_post( $post );
    156160
    157161                // fetch the post and make sure has the correct date and status
    158                 $out = get_post($id);
    159                 $this->assertEquals('future', $out->post_status);
    160                 $this->assertEquals($post['post_date'], $out->post_date);
     162                $out = get_post( $id );
     163                $this->assertEquals( 'future', $out->post_status );
     164                $this->assertEquals( $post['post_date'], $out->post_date );
    161165
    162166                // check that there's a publish_future_post job scheduled at the right time
    163                 $this->assertEquals($future_date_1, $this->_next_schedule_for_post('publish_future_post', $id));
     167                $this->assertEquals( $future_date_1, $this->_next_schedule_for_post( 'publish_future_post', $id ) );
    164168
    165169                // now save it again with a date further in the future
    166170
    167                 $post['ID'] = $id;
    168                 $post['post_date'] = strftime("%Y-%m-%d %H:%M:%S", $future_date_2);
    169                 $post['post_date_gmt'] = NULL;
    170                 wp_update_post($post);
     171                $post['ID']            = $id;
     172                $post['post_date']     = strftime( '%Y-%m-%d %H:%M:%S', $future_date_2 );
     173                $post['post_date_gmt'] = null;
     174                wp_update_post( $post );
    171175
    172176                // fetch the post again and make sure it has the new post_date
    173                 $out = get_post($id);
    174                 $this->assertEquals('future', $out->post_status);
    175                 $this->assertEquals($post['post_date'], $out->post_date);
     177                $out = get_post( $id );
     178                $this->assertEquals( 'future', $out->post_status );
     179                $this->assertEquals( $post['post_date'], $out->post_date );
    176180
    177181                // and the correct date on the cron job
    178                 $this->assertEquals($future_date_2, $this->_next_schedule_for_post('publish_future_post', $id));
     182                $this->assertEquals( $future_date_2, $this->_next_schedule_for_post( 'publish_future_post', $id ) );
    179183        }
    180184
    … …  
    183187                // https://core.trac.wordpress.org/ticket/4710
    184188
    185                 $future_date_1 = strtotime('+1 day');
    186                 $future_date_2 = strtotime('+2 day');
     189                $future_date_1 = strtotime( '+1 day' );
     190                $future_date_2 = strtotime( '+2 day' );
    187191
    188192                $post = array(
    189                         'post_author' => self::$editor_id,
    190                         'post_status' => 'publish',
     193                        'post_author'  => self::$editor_id,
     194                        'post_status'  => 'publish',
    191195                        'post_content' => rand_str(),
    192                         'post_title' => rand_str(),
    193                         'post_date'  => strftime("%Y-%m-%d %H:%M:%S", $future_date_1),
     196                        'post_title'   => rand_str(),
     197                        'post_date'    => strftime( '%Y-%m-%d %H:%M:%S', $future_date_1 ),
    194198                );
    195199
    196200                // insert a post and make sure the ID is ok
    197                 $id = $this->post_ids[] = wp_insert_post($post);
     201                $id = $this->post_ids[] = wp_insert_post( $post );
    198202
    199203                // fetch the post and make sure has the correct date and status
    200                 $out = get_post($id);
    201                 $this->assertEquals('future', $out->post_status);
    202                 $this->assertEquals($post['post_date'], $out->post_date);
     204                $out = get_post( $id );
     205                $this->assertEquals( 'future', $out->post_status );
     206                $this->assertEquals( $post['post_date'], $out->post_date );
    203207
    204208                // check that there's a publish_future_post job scheduled at the right time
    205                 $this->assertEquals($future_date_1, $this->_next_schedule_for_post('publish_future_post', $id));
     209                $this->assertEquals( $future_date_1, $this->_next_schedule_for_post( 'publish_future_post', $id ) );
    206210
    207211                // now save it again with a date further in the future
    208212
    209                 $post['ID'] = $id;
    210                 $post['post_date'] = strftime("%Y-%m-%d %H:%M:%S", $future_date_2);
    211                 $post['post_date_gmt'] = NULL;
    212                 wp_update_post($post);
     213                $post['ID']            = $id;
     214                $post['post_date']     = strftime( '%Y-%m-%d %H:%M:%S', $future_date_2 );
     215                $post['post_date_gmt'] = null;
     216                wp_update_post( $post );
    213217
    214218                // fetch the post again and make sure it has the new post_date
    215                 $out = get_post($id);
    216                 $this->assertEquals('future', $out->post_status);
    217                 $this->assertEquals($post['post_date'], $out->post_date);
     219                $out = get_post( $id );
     220                $this->assertEquals( 'future', $out->post_status );
     221                $this->assertEquals( $post['post_date'], $out->post_date );
    218222
    219223                // and the correct date on the cron job
    220                 $this->assertEquals($future_date_2, $this->_next_schedule_for_post('publish_future_post', $id));
     224                $this->assertEquals( $future_date_2, $this->_next_schedule_for_post( 'publish_future_post', $id ) );
    221225        }
    222226
    … …  
    224228                // insert a draft post with a future date, and make sure no cron schedule is set
    225229
    226                 $future_date = strtotime('+1 day');
     230                $future_date = strtotime( '+1 day' );
    227231
    228232                $post = array(
    229                         'post_author' => self::$editor_id,
    230                         'post_status' => 'draft',
     233                        'post_author'  => self::$editor_id,
     234                        'post_status'  => 'draft',
    231235                        'post_content' => rand_str(),
    232                         'post_title' => rand_str(),
    233                         'post_date'  => strftime("%Y-%m-%d %H:%M:%S", $future_date),
     236                        'post_title'   => rand_str(),
     237                        'post_date'    => strftime( '%Y-%m-%d %H:%M:%S', $future_date ),
    234238                );
    235239
    236240                // insert a post and make sure the ID is ok
    237                 $id = $this->post_ids[] = wp_insert_post($post);
     241                $id = $this->post_ids[] = wp_insert_post( $post );
    238242                #dmp(_get_cron_array());
    239                 $this->assertTrue(is_numeric($id));
    240                 $this->assertTrue($id > 0);
     243                $this->assertTrue( is_numeric( $id ) );
     244                $this->assertTrue( $id > 0 );
    241245
    242246                // fetch the post and make sure it matches
    243                 $out = get_post($id);
    244 
    245                 $this->assertEquals($post['post_content'], $out->post_content);
    246                 $this->assertEquals($post['post_title'], $out->post_title);
    247                 $this->assertEquals('draft', $out->post_status);
    248                 $this->assertEquals($post['post_author'], $out->post_author);
    249                 $this->assertEquals($post['post_date'], $out->post_date);
     247                $out = get_post( $id );
     248
     249                $this->assertEquals( $post['post_content'], $out->post_content );
     250                $this->assertEquals( $post['post_title'], $out->post_title );
     251                $this->assertEquals( 'draft', $out->post_status );
     252                $this->assertEquals( $post['post_author'], $out->post_author );
     253                $this->assertEquals( $post['post_date'], $out->post_date );
    250254
    251255                // there should be a publish_future_post hook scheduled on the future date
    252                 $this->assertEquals(false, $this->_next_schedule_for_post('publish_future_post', $id));
     256                $this->assertEquals( false, $this->_next_schedule_for_post( 'publish_future_post', $id ) );
    253257
    254258        }
    … …  
    256260        function test_vb_insert_future_change_to_draft() {
    257261                // insert a future post, then edit and change it to draft, and make sure cron gets it right
    258                 $future_date_1 = strtotime('+1 day');
     262                $future_date_1 = strtotime( '+1 day' );
    259263
    260264                $post = array(
    261                         'post_author' => self::$editor_id,
    262                         'post_status' => 'publish',
     265                        'post_author'  => self::$editor_id,
     266                        'post_status'  => 'publish',
    263267                        'post_content' => rand_str(),
    264                         'post_title' => rand_str(),
    265                         'post_date'  => strftime("%Y-%m-%d %H:%M:%S", $future_date_1),
     268                        'post_title'   => rand_str(),
     269                        'post_date'    => strftime( '%Y-%m-%d %H:%M:%S', $future_date_1 ),
    266270                );
    267271
    268272                // insert a post and make sure the ID is ok
    269                 $id = $this->post_ids[] = wp_insert_post($post);
     273                $id = $this->post_ids[] = wp_insert_post( $post );
    270274
    271275                // fetch the post and make sure has the correct date and status
    272                 $out = get_post($id);
    273                 $this->assertEquals('future', $out->post_status);
    274                 $this->assertEquals($post['post_date'], $out->post_date);
     276                $out = get_post( $id );
     277                $this->assertEquals( 'future', $out->post_status );
     278                $this->assertEquals( $post['post_date'], $out->post_date );
    275279
    276280                // check that there's a publish_future_post job scheduled at the right time
    277                 $this->assertEquals($future_date_1, $this->_next_schedule_for_post('publish_future_post', $id));
     281                $this->assertEquals( $future_date_1, $this->_next_schedule_for_post( 'publish_future_post', $id ) );
    278282
    279283                // now save it again with status set to draft
    280284
    281                 $post['ID'] = $id;
     285                $post['ID']          = $id;
    282286                $post['post_status'] = 'draft';
    283                 wp_update_post($post);
     287                wp_update_post( $post );
    284288
    285289                // fetch the post again and make sure it has the new post_date
    286                 $out = get_post($id);
    287                 $this->assertEquals('draft', $out->post_status);
    288                 $this->assertEquals($post['post_date'], $out->post_date);
     290                $out = get_post( $id );
     291                $this->assertEquals( 'draft', $out->post_status );
     292                $this->assertEquals( $post['post_date'], $out->post_date );
    289293
    290294                // and the correct date on the cron job
    291                 $this->assertEquals(false, $this->_next_schedule_for_post('publish_future_post', $id));
     295                $this->assertEquals( false, $this->_next_schedule_for_post( 'publish_future_post', $id ) );
    292296        }
    293297
    294298        function test_vb_insert_future_change_status() {
    295299                // insert a future post, then edit and change the status, and make sure cron gets it right
    296                 $future_date_1 = strtotime('+1 day');
    297 
    298                 $statuses = array('draft', 'static', 'object', 'attachment', 'inherit', 'pending');
    299 
    300                 foreach ($statuses as $status) {
     300                $future_date_1 = strtotime( '+1 day' );
     301
     302                $statuses = array( 'draft', 'static', 'object', 'attachment', 'inherit', 'pending' );
     303
     304                foreach ( $statuses as $status ) {
    301305                        $post = array(
    302                                 'post_author' => self::$editor_id,
    303                                 'post_status' => 'publish',
     306                                'post_author'  => self::$editor_id,
     307                                'post_status'  => 'publish',
    304308                                'post_content' => rand_str(),
    305                                 'post_title' => rand_str(),
    306                                 'post_date'  => strftime("%Y-%m-%d %H:%M:%S", $future_date_1),
     309                                'post_title'   => rand_str(),
     310                                'post_date'    => strftime( '%Y-%m-%d %H:%M:%S', $future_date_1 ),
    307311                        );
    308312
    309313                        // insert a post and make sure the ID is ok
    310                         $id = $this->post_ids[] = wp_insert_post($post);
     314                        $id = $this->post_ids[] = wp_insert_post( $post );
    311315
    312316                        // fetch the post and make sure has the correct date and status
    313                         $out = get_post($id);
    314                         $this->assertEquals('future', $out->post_status);
    315                         $this->assertEquals($post['post_date'], $out->post_date);
     317                        $out = get_post( $id );
     318                        $this->assertEquals( 'future', $out->post_status );
     319                        $this->assertEquals( $post['post_date'], $out->post_date );
    316320
    317321                        // check that there's a publish_future_post job scheduled at the right time
    318                         $this->assertEquals($future_date_1, $this->_next_schedule_for_post('publish_future_post', $id));
     322                        $this->assertEquals( $future_date_1, $this->_next_schedule_for_post( 'publish_future_post', $id ) );
    319323
    320324                        // now save it again with status changed
    321325
    322                         $post['ID'] = $id;
     326                        $post['ID']          = $id;
    323327                        $post['post_status'] = $status;
    324                         wp_update_post($post);
     328                        wp_update_post( $post );
    325329
    326330                        // fetch the post again and make sure it has the new post_date
    327                         $out = get_post($id);
    328                         $this->assertEquals($status, $out->post_status);
    329                         $this->assertEquals($post['post_date'], $out->post_date);
     331                        $out = get_post( $id );
     332                        $this->assertEquals( $status, $out->post_status );
     333                        $this->assertEquals( $post['post_date'], $out->post_date );
    330334
    331335                        // and the correct date on the cron job
    332                         $this->assertEquals(false, $this->_next_schedule_for_post('publish_future_post', $id));
     336                        $this->assertEquals( false, $this->_next_schedule_for_post( 'publish_future_post', $id ) );
    333337                }
    334338        }
    … …  
    337341                // insert a draft post with a future date, and make sure no cron schedule is set
    338342
    339                 $future_date = strtotime('+1 day');
     343                $future_date = strtotime( '+1 day' );
    340344
    341345                $post = array(
    342                         'post_author' => self::$editor_id,
    343                         'post_status' => 'private',
     346                        'post_author'  => self::$editor_id,
     347                        'post_status'  => 'private',
    344348                        'post_content' => rand_str(),
    345                         'post_title' => rand_str(),
    346                         'post_date'  => strftime("%Y-%m-%d %H:%M:%S", $future_date),
     349                        'post_title'   => rand_str(),
     350                        'post_date'    => strftime( '%Y-%m-%d %H:%M:%S', $future_date ),
    347351                );
    348352
    349353                // insert a post and make sure the ID is ok
    350                 $id = $this->post_ids[] = wp_insert_post($post);
     354                $id = $this->post_ids[] = wp_insert_post( $post );
    351355                #dmp(_get_cron_array());
    352                 $this->assertTrue(is_numeric($id));
    353                 $this->assertTrue($id > 0);
     356                $this->assertTrue( is_numeric( $id ) );
     357                $this->assertTrue( $id > 0 );
    354358
    355359                // fetch the post and make sure it matches
    356                 $out = get_post($id);
    357 
    358                 $this->assertEquals($post['post_content'], $out->post_content);
    359                 $this->assertEquals($post['post_title'], $out->post_title);
    360                 $this->assertEquals('private', $out->post_status);
    361                 $this->assertEquals($post['post_author'], $out->post_author);
    362                 $this->assertEquals($post['post_date'], $out->post_date);
     360                $out = get_post( $id );
     361
     362                $this->assertEquals( $post['post_content'], $out->post_content );
     363                $this->assertEquals( $post['post_title'], $out->post_title );
     364                $this->assertEquals( 'private', $out->post_status );
     365                $this->assertEquals( $post['post_author'], $out->post_author );
     366                $this->assertEquals( $post['post_date'], $out->post_date );
    363367
    364368                // there should be a publish_future_post hook scheduled on the future date
    365                 $this->assertEquals(false, $this->_next_schedule_for_post('publish_future_post', $id));
     369                $this->assertEquals( false, $this->_next_schedule_for_post( 'publish_future_post', $id ) );
    366370        }
    367371
    … …  
    373377
    374378                $post = array(
    375                         'post_author' => self::$editor_id,
    376                         'post_status' => 'public',
     379                        'post_author'  => self::$editor_id,
     380                        'post_status'  => 'public',
    377381                        'post_content' => rand_str(),
    378                         'post_title' => rand_str(),
    379                         'post_date'  => '2012-02-30 00:00:00',
     382                        'post_title'   => rand_str(),
     383                        'post_date'    => '2012-02-30 00:00:00',
    380384                );
    381385
    … …  
    391395        function test_vb_insert_future_change_to_private() {
    392396                // insert a future post, then edit and change it to private, and make sure cron gets it right
    393                 $future_date_1 = strtotime('+1 day');
     397                $future_date_1 = strtotime( '+1 day' );
    394398
    395399                $post = array(
    396                         'post_author' => self::$editor_id,
    397                         'post_status' => 'publish',
     400                        'post_author'  => self::$editor_id,
     401                        'post_status'  => 'publish',
    398402                        'post_content' => rand_str(),
    399                         'post_title' => rand_str(),
    400                         'post_date'  => strftime("%Y-%m-%d %H:%M:%S", $future_date_1),
     403                        'post_title'   => rand_str(),
     404                        'post_date'    => strftime( '%Y-%m-%d %H:%M:%S', $future_date_1 ),
    401405                );
    402406
    403407                // insert a post and make sure the ID is ok
    404                 $id = $this->post_ids[] = wp_insert_post($post);
     408                $id = $this->post_ids[] = wp_insert_post( $post );
    405409
    406410                // fetch the post and make sure has the correct date and status
    407                 $out = get_post($id);
    408                 $this->assertEquals('future', $out->post_status);
    409                 $this->assertEquals($post['post_date'], $out->post_date);
     411                $out = get_post( $id );
     412                $this->assertEquals( 'future', $out->post_status );
     413                $this->assertEquals( $post['post_date'], $out->post_date );
    410414
    411415                // check that there's a publish_future_post job scheduled at the right time
    412                 $this->assertEquals($future_date_1, $this->_next_schedule_for_post('publish_future_post', $id));
     416                $this->assertEquals( $future_date_1, $this->_next_schedule_for_post( 'publish_future_post', $id ) );
    413417
    414418                // now save it again with status set to draft
    415419
    416                 $post['ID'] = $id;
     420                $post['ID']          = $id;
    417421                $post['post_status'] = 'private';
    418                 wp_update_post($post);
     422                wp_update_post( $post );
    419423
    420424                // fetch the post again and make sure it has the new post_date
    421                 $out = get_post($id);
    422                 $this->assertEquals('private', $out->post_status);
    423                 $this->assertEquals($post['post_date'], $out->post_date);
     425                $out = get_post( $id );
     426                $this->assertEquals( 'private', $out->post_status );
     427                $this->assertEquals( $post['post_date'], $out->post_date );
    424428
    425429                // and the correct date on the cron job
    426                 $this->assertEquals(false, $this->_next_schedule_for_post('publish_future_post', $id));
     430                $this->assertEquals( false, $this->_next_schedule_for_post( 'publish_future_post', $id ) );
    427431        }
    428432
    … …  
    433437                $this->set_permalink_structure( '/%postname%/' );
    434438
    435                 $p = wp_insert_post( array(
    436                         'post_title' => '',
    437                         'post_content' => 'test',
    438                         'post_status' => 'publish',
    439                         'post_type' => 'post',
    440                 ) );
     439                $p = wp_insert_post(
     440                        array(
     441                                'post_title'   => '',
     442                                'post_content' => 'test',
     443                                'post_status'  => 'publish',
     444                                'post_type'    => 'post',
     445                        )
     446                );
    441447
    442448                $post = get_post( $p );
    … …  
    451457         * @ticket 33392
    452458         */
    453         public function test_wp_insert_post_should_invalidate_post_cache_before_generating_guid_when_post_name_is_empty_and_is_generated_from_the_post_ID(){
     459        public function test_wp_insert_post_should_invalidate_post_cache_before_generating_guid_when_post_name_is_empty_and_is_generated_from_the_post_ID() {
    454460                register_post_type( 'wptests_pt' );
    455461
    456                 $p = wp_insert_post( array(
    457                         'post_title' => '',
    458                         'post_type' => 'wptests_pt',
    459                         'post_status' => 'publish',
    460                 ) );
     462                $p = wp_insert_post(
     463                        array(
     464                                'post_title'  => '',
     465                                'post_type'   => 'wptests_pt',
     466                                'post_status' => 'publish',
     467                        )
     468                );
    461469
    462470                $post = get_post( $p );
    … …  
    469477         */
    470478        public function test_wp_insert_post_with_meta_input() {
    471                 $post_id = wp_insert_post( array(
    472                         'post_title'   => '',
    473                         'post_content' => 'test',
    474                         'post_status'  => 'publish',
    475                         'post_type'    => 'post',
    476                         'meta_input'   => array(
    477                                 'hello' => 'world',
    478                                 'foo'   => 'bar'
    479                         )
    480                 ) );
     479                $post_id = wp_insert_post(
     480                        array(
     481                                'post_title'   => '',
     482                                'post_content' => 'test',
     483                                'post_status'  => 'publish',
     484                                'post_type'    => 'post',
     485                                'meta_input'   => array(
     486                                        'hello' => 'world',
     487                                        'foo'   => 'bar',
     488                                ),
     489                        )
     490                );
    481491
    482492                $this->assertEquals( 'world', get_post_meta( $post_id, 'hello', true ) );
    … …  
    489499        function test_delete_future_post_cron() {
    490500                // "When I delete a future post using wp_delete_post($post->ID) it does not update the cron correctly."
    491                 $future_date = strtotime('+1 day');
     501                $future_date = strtotime( '+1 day' );
    492502
    493503                $post = array(
    494                         'post_author' => self::$editor_id,
    495                         'post_status' => 'publish',
     504                        'post_author'  => self::$editor_id,
     505                        'post_status'  => 'publish',
    496506                        'post_content' => rand_str(),
    497                         'post_title' => rand_str(),
    498                         'post_date'  => strftime("%Y-%m-%d %H:%M:%S", $future_date),
     507                        'post_title'   => rand_str(),
     508                        'post_date'    => strftime( '%Y-%m-%d %H:%M:%S', $future_date ),
    499509                );
    500510
    501511                // insert a post and make sure the ID is ok
    502                 $id = $this->post_ids[] = wp_insert_post($post);
     512                $id = $this->post_ids[] = wp_insert_post( $post );
    503513
    504514                // check that there's a publish_future_post job scheduled at the right time
    505                 $this->assertEquals($future_date, $this->_next_schedule_for_post('publish_future_post', $id));
     515                $this->assertEquals( $future_date, $this->_next_schedule_for_post( 'publish_future_post', $id ) );
    506516
    507517                // now delete the post and make sure the cron entry is removed
    508518                wp_delete_post( $id );
    509519
    510                 $this->assertFalse($this->_next_schedule_for_post('publish_future_post', $id));
     520                $this->assertFalse( $this->_next_schedule_for_post( 'publish_future_post', $id ) );
    511521        }
    512522
    … …  
    518528                // might only fail if the post ID is greater than four characters
    519529
    520                 $this->set_permalink_structure('/%year%/%monthnum%/%day%/%postname%/');
     530                $this->set_permalink_structure( '/%year%/%monthnum%/%day%/%postname%/' );
    521531
    522532                $post = array(
    523                         'post_author' => self::$editor_id,
    524                         'post_status' => 'publish',
     533                        'post_author'  => self::$editor_id,
     534                        'post_status'  => 'publish',
    525535                        'post_content' => rand_str(),
    526                         'post_title' => '',
    527                         'post_date' => '2007-10-31 06:15:00',
     536                        'post_title'   => '',
     537                        'post_date'    => '2007-10-31 06:15:00',
    528538                );
    529539
    530540                // insert a post and make sure the ID is ok
    531                 $id = $this->post_ids[] = wp_insert_post($post);
    532 
    533                 $plink = get_permalink($id);
     541                $id = $this->post_ids[] = wp_insert_post( $post );
     542
     543                $plink = get_permalink( $id );
    534544
    535545                // permalink should include the post ID at the end
    536                 $this->assertEquals(get_option('siteurl').'/2007/10/31/'.$id.'/', $plink);
     546                $this->assertEquals( get_option( 'siteurl' ) . '/2007/10/31/' . $id . '/', $plink );
    537547        }
    538548
    … …  
    543553                global $wpdb;
    544554
    545                 $attachment = self::factory()->post->create_and_get( array( 'post_title' => 'some-page', 'post_type' => 'attachment' ) );
    546                 $page       = self::factory()->post->create_and_get( array( 'post_title' => 'some-page', 'post_type' => 'page' ) );
    547                 $other_att  = self::factory()->post->create_and_get( array( 'post_title' => 'some-other-page', 'post_type' => 'attachment' ) );
     555                $attachment = self::factory()->post->create_and_get(
     556                        array(
     557                                'post_title' => 'some-page',
     558                                'post_type'  => 'attachment',
     559                        )
     560                );
     561                $page       = self::factory()->post->create_and_get(
     562                        array(
     563                                'post_title' => 'some-page',
     564                                'post_type'  => 'page',
     565                        )
     566                );
     567                $other_att  = self::factory()->post->create_and_get(
     568                        array(
     569                                'post_title' => 'some-other-page',
     570                                'post_type'  => 'attachment',
     571                        )
     572                );
    548573
    549574                $wpdb->update( $wpdb->posts, array( 'post_name' => 'some-page' ), array( 'ID' => $page->ID ) );
    … …  
    579604        function test_wp_insert_post_and_wp_publish_post_with_future_date() {
    580605                $future_date = gmdate( 'Y-m-d H:i:s', time() + 10000000 );
    581                 $post_id = self::factory()->post->create( array(
    582                         'post_status' => 'publish',
    583                         'post_date' => $future_date,
    584                 ) );
     606                $post_id     = self::factory()->post->create(
     607                        array(
     608                                'post_status' => 'publish',
     609                                'post_date'   => $future_date,
     610                        )
     611                );
    585612
    586613                $post = get_post( $post_id );
    … …  
    602629
    603630                $post_id = wp_insert_post( array( 'post_title' => '<script>Test</script>' ) );
    604                 $post = get_post( $post_id );
     631                $post    = get_post( $post_id );
    605632                $this->assertEquals( '<script>Test</script>', $post->post_title );
    606633                $this->assertEquals( 'draft', $post->post_status );
    … …  
    608635                kses_init_filters();
    609636
    610                 wp_update_post( array( 'ID' => $post->ID, 'post_status' => 'publish' ) );
     637                wp_update_post(
     638                        array(
     639                                'ID'          => $post->ID,
     640                                'post_status' => 'publish',
     641                        )
     642                );
    611643                $post = get_post( $post->ID );
    612644                $this->assertEquals( 'Test', $post->post_title );
    … …  
    622654
    623655                $post_id = wp_insert_post( array( 'post_title' => '<script>Test</script>' ) );
    624                 $post = get_post( $post_id );
     656                $post    = get_post( $post_id );
    625657                $this->assertEquals( '<script>Test</script>', $post->post_title );
    626658                $this->assertEquals( 'draft', $post->post_status );
    … …  
    641673                global $post;
    642674                $parent_id = self::factory()->post->create();
    643                 $post = self::factory()->post->create_and_get( array( 'post_parent' => $parent_id ) );
     675                $post      = self::factory()->post->create_and_get( array( 'post_parent' => $parent_id ) );
    644676                $this->assertEquals( array( $parent_id ), get_post_ancestors( 0 ) );
    645677        }
    … …  
    650682        function test_update_invalid_post_id() {
    651683                $post_id = self::factory()->post->create( array( 'post_name' => 'get-page-uri-post-name' ) );
    652                 $post = get_post( $post_id, ARRAY_A );
     684                $post    = get_post( $post_id, ARRAY_A );
    653685
    654686                $post['ID'] = 123456789;
    … …  
    665697                global $multipage, $pages, $numpages;
    666698                $post_id = self::factory()->post->create( array( 'post_content' => 'Page 0' ) );
    667                 $post = get_post( $post_id );
     699                $post    = get_post( $post_id );
    668700                setup_postdata( $post );
    669701                $this->assertEquals( 0, $multipage );
    670                 $this->assertCount(  1, $pages );
     702                $this->assertCount( 1, $pages );
    671703                $this->assertEquals( 1, $numpages );
    672704                $this->assertEquals( array( 'Page 0' ), $pages );
    … …  
    676708                global $multipage, $pages, $numpages;
    677709                $post_id = self::factory()->post->create( array( 'post_content' => 'Page 0<!--nextpage-->Page 1<!--nextpage-->Page 2<!--nextpage-->Page 3' ) );
    678                 $post = get_post( $post_id );
     710                $post    = get_post( $post_id );
    679711                setup_postdata( $post );
    680712                $this->assertEquals( 1, $multipage );
    681                 $this->assertCount(  4, $pages );
     713                $this->assertCount( 4, $pages );
    682714                $this->assertEquals( 4, $numpages );
    683715                $this->assertEquals( array( 'Page 0', 'Page 1', 'Page 2', 'Page 3' ), $pages );
    … …  
    687719                global $multipage, $pages, $numpages;
    688720                $post_id = self::factory()->post->create( array( 'post_content' => 'Page 0' ) );
    689                 $post = get_post( $post_id );
     721                $post    = get_post( $post_id );
    690722                setup_postdata( $post );
    691723                $this->assertEquals( 0, $multipage );
    692                 $this->assertCount(  1, $pages );
     724                $this->assertCount( 1, $pages );
    693725                $this->assertEquals( 1, $numpages );
    694726                $this->assertEquals( array( 'Page 0' ), $pages );
    … …  
    698730                global $multipage, $pages, $numpages;
    699731                $post_id = self::factory()->post->create( array( 'post_content' => 'Page 0<!--nextpage-->Page 1<!--nextpage-->Page 2<!--nextpage-->Page 3' ) );
    700                 $post = get_post( $post_id );
     732                $post    = get_post( $post_id );
    701733                setup_postdata( $post );
    702734                $this->assertEquals( 1, $multipage );
    703                 $this->assertCount(  4, $pages );
     735                $this->assertCount( 4, $pages );
    704736                $this->assertEquals( 4, $numpages );
    705737                $this->assertEquals( array( 'Page 0', 'Page 1', 'Page 2', 'Page 3' ), $pages );
    … …  
    712744                global $multipage, $pages, $numpages;
    713745                $post_id = self::factory()->post->create( array( 'post_content' => '<!--nextpage-->Page 0<!--nextpage-->Page 1<!--nextpage-->Page 2<!--nextpage-->Page 3' ) );
    714                 $post = get_post( $post_id );
     746                $post    = get_post( $post_id );
    715747                setup_postdata( $post );
    716748                $this->assertEquals( 1, $multipage );
    717                 $this->assertCount(  4, $pages );
     749                $this->assertCount( 4, $pages );
    718750                $this->assertEquals( 4, $numpages );
    719751                $this->assertEquals( array( 'Page 0', 'Page 1', 'Page 2', 'Page 3' ), $pages );
    … …  
    726758                global $multipage, $pages, $numpages;
    727759                $post_id = self::factory()->post->create( array( 'post_content' => '<!--nextpage-->Page 0' ) );
    728                 $post = get_post( $post_id );
     760                $post    = get_post( $post_id );
    729761                setup_postdata( $post );
    730762                $this->assertEquals( 0, $multipage );
    731                 $this->assertCount(  1, $pages );
     763                $this->assertCount( 1, $pages );
    732764                $this->assertEquals( 1, $numpages );
    733765                $this->assertEquals( array( 'Page 0' ), $pages );
    … …  
    742774                register_taxonomy( 'test_tax', 'post' );
    743775
    744                 $title = rand_str();
    745                 $post_data = array(
    746                         'post_author' => self::$editor_id,
    747                         'post_status' => 'public',
     776                $title          = rand_str();
     777                $post_data      = array(
     778                        'post_author'  => self::$editor_id,
     779                        'post_status'  => 'public',
    748780                        'post_content' => rand_str(),
    749                         'post_title' => $title,
    750                         'tax_input' => array(
    751                                 'test_tax' => array( 'term', 'term2', 'term3' )
    752                         )
     781                        'post_title'   => $title,
     782                        'tax_input'    => array(
     783                                'test_tax' => array( 'term', 'term2', 'term3' ),
     784                        ),
    753785                );
    754786                $insert_post_id = wp_insert_post( $post_data, true, true );
    755                 $this->assertTrue( ( is_int($insert_post_id) && $insert_post_id > 0 ) );
     787                $this->assertTrue( ( is_int( $insert_post_id ) && $insert_post_id > 0 ) );
    756788
    757789                $post = get_post( $insert_post_id );
    … …  
    764796         */
    765797        function test_wp_count_posts() {
    766                 $post_type = rand_str(20);
     798                $post_type = rand_str( 20 );
    767799                register_post_type( $post_type );
    768                 self::factory()->post->create( array(
    769                         'post_type' => $post_type,
    770                         'post_author' => self::$editor_id
    771                 ) );
     800                self::factory()->post->create(
     801                        array(
     802                                'post_type'   => $post_type,
     803                                'post_author' => self::$editor_id,
     804                        )
     805                );
    772806                $count = wp_count_posts( $post_type, 'readable' );
    773807                $this->assertEquals( 1, $count->publish );
    … …  
    777811
    778812        function test_wp_count_posts_filtered() {
    779                 $post_type = rand_str(20);
     813                $post_type = rand_str( 20 );
    780814                register_post_type( $post_type );
    781                 self::factory()->post->create_many( 3, array(
    782                         'post_type' => $post_type,
    783                         'post_author' => self::$editor_id
    784                 ) );
     815                self::factory()->post->create_many(
     816                        3, array(
     817                                'post_type'   => $post_type,
     818                                'post_author' => self::$editor_id,
     819                        )
     820                );
    785821                $count1 = wp_count_posts( $post_type, 'readable' );
    786822                $this->assertEquals( 3, $count1->publish );
    … …  
    799835
    800836        function test_wp_count_posts_insert_invalidation() {
    801                 $post_ids = self::factory()->post->create_many( 3 );
     837                $post_ids       = self::factory()->post->create_many( 3 );
    802838                $initial_counts = wp_count_posts();
    803839
    804                 $key = array_rand( $post_ids );
    805                 $_post = get_post( $post_ids[$key], ARRAY_A );
     840                $key                  = array_rand( $post_ids );
     841                $_post                = get_post( $post_ids[ $key ], ARRAY_A );
    806842                $_post['post_status'] = 'draft';
    807843                wp_insert_post( $_post );
    808                 $post = get_post( $post_ids[$key] );
     844                $post = get_post( $post_ids[ $key ] );
    809845                $this->assertEquals( 'draft', $post->post_status );
    810846                $this->assertNotEquals( 'publish', $post->post_status );
    … …  
    817853
    818854        function test_wp_count_posts_trash_invalidation() {
    819                 $post_ids = self::factory()->post->create_many( 3 );
     855                $post_ids       = self::factory()->post->create_many( 3 );
    820856                $initial_counts = wp_count_posts();
    821857
    822858                $key = array_rand( $post_ids );
    823859
    824                 wp_trash_post( $post_ids[$key] );
    825 
    826                 $post = get_post( $post_ids[$key] );
     860                wp_trash_post( $post_ids[ $key ] );
     861
     862                $post = get_post( $post_ids[ $key ] );
    827863                $this->assertEquals( 'trash', $post->post_status );
    828864                $this->assertNotEquals( 'publish', $post->post_status );
    … …  
    926962        function test_wp_tag_cloud_link_with_post_type() {
    927963                $post_type = 'new_post_type';
    928                 $tax = 'new_tag';
     964                $tax       = 'new_tag';
    929965                register_post_type( $post_type, array( 'taxonomies' => array( 'post_tag', $tax ) ) );
    930966                register_taxonomy( $tax, $post_type );
    … …  
    933969                wp_set_object_terms( $post, rand_str(), $tax );
    934970
    935                 $wp_tag_cloud = wp_tag_cloud( array(
    936                         'post_type' => $post_type,
    937                         'taxonomy' => $tax,
    938                         'echo' => false,
    939                         'link' => 'edit'
    940                 ) );
     971                $wp_tag_cloud = wp_tag_cloud(
     972                        array(
     973                                'post_type' => $post_type,
     974                                'taxonomy'  => $tax,
     975                                'echo'      => false,
     976                                'link'      => 'edit',
     977                        )
     978                );
    941979
    942980                preg_match_all( '|href="([^"]+)"|', $wp_tag_cloud, $matches );
    … …  
    944982
    945983                $terms = get_terms( $tax );
    946                 $term = reset( $terms );
     984                $term  = reset( $terms );
    947985
    948986                foreach ( $matches[1] as $url ) {
    … …  
    9711009                        'post_title'   => "foo\xf0\x9f\x98\x88bar",
    9721010                        'post_content' => "foo\xf0\x9f\x98\x8ebaz",
    973                         'post_excerpt' => "foo\xf0\x9f\x98\x90bat"
     1011                        'post_excerpt' => "foo\xf0\x9f\x98\x90bat",
    9741012                );
    9751013
    9761014                $expected = array(
    977                         'post_title'   => "foo&#x1f608;bar",
    978                         'post_content' => "foo&#x1f60e;baz",
    979                         'post_excerpt' => "foo&#x1f610;bat"
     1015                        'post_title'   => 'foo&#x1f608;bar',
     1016                        'post_content' => 'foo&#x1f60e;baz',
     1017                        'post_excerpt' => 'foo&#x1f610;bat',
    9801018                );
    9811019
    … …  
    9841022                $post = get_post( $post_id );
    9851023
    986                 foreach( $expected as $field => $value ) {
     1024                foreach ( $expected as $field => $value ) {
    9871025                        $this->assertEquals( $value, $post->$field );
    9881026                }
    … …  
    9931031         */
    9941032        function test_wp_insert_post_default_comment_ping_status_open() {
    995                 $post_id = self::factory()->post->create( array(
    996                         'post_author' => self::$editor_id,
    997                         'post_status' => 'public',
    998                         'post_content' => rand_str(),
    999                         'post_title' => rand_str(),
    1000                 ) );
    1001                 $post = get_post( $post_id );
     1033                $post_id = self::factory()->post->create(
     1034                        array(
     1035                                'post_author'  => self::$editor_id,
     1036                                'post_status'  => 'public',
     1037                                'post_content' => rand_str(),
     1038                                'post_title'   => rand_str(),
     1039                        )
     1040                );
     1041                $post    = get_post( $post_id );
    10021042
    10031043                $this->assertEquals( 'open', $post->comment_status );
    … …  
    10091049         */
    10101050        function test_wp_insert_post_page_default_comment_ping_status_closed() {
    1011                 $post_id = self::factory()->post->create( array(
    1012                         'post_author' => self::$editor_id,
    1013                         'post_status' => 'public',
    1014                         'post_content' => rand_str(),
    1015                         'post_title' => rand_str(),
    1016                         'post_type' => 'page',
    1017                 ) );
    1018                 $post = get_post( $post_id );
     1051                $post_id = self::factory()->post->create(
     1052                        array(
     1053                                'post_author'  => self::$editor_id,
     1054                                'post_status'  => 'public',
     1055                                'post_content' => rand_str(),
     1056                                'post_title'   => rand_str(),
     1057                                'post_type'    => 'page',
     1058                        )
     1059                );
     1060                $post    = get_post( $post_id );
    10191061
    10201062                $this->assertEquals( 'closed', $post->comment_status );
    … …  
    10261068         */
    10271069        function test_wp_insert_post_cpt_default_comment_ping_status_open() {
    1028                 $post_type = rand_str(20);
     1070                $post_type = rand_str( 20 );
    10291071                register_post_type( $post_type, array( 'supports' => array( 'comments', 'trackbacks' ) ) );
    1030                 $post_id = self::factory()->post->create( array(
    1031                         'post_author' => self::$editor_id,
    1032                         'post_status' => 'public',
    1033                         'post_content' => rand_str(),
    1034                         'post_title' => rand_str(),
    1035                         'post_type' => $post_type,
    1036                 ) );
    1037                 $post = get_post( $post_id );
     1072                $post_id = self::factory()->post->create(
     1073                        array(
     1074                                'post_author'  => self::$editor_id,
     1075                                'post_status'  => 'public',
     1076                                'post_content' => rand_str(),
     1077                                'post_title'   => rand_str(),
     1078                                'post_type'    => $post_type,
     1079                        )
     1080                );
     1081                $post    = get_post( $post_id );
    10381082
    10391083                $this->assertEquals( 'open', $post->comment_status );
    … …  
    10461090         */
    10471091        function test_wp_insert_post_cpt_default_comment_ping_status_closed() {
    1048                 $post_type = rand_str(20);
     1092                $post_type = rand_str( 20 );
    10491093                register_post_type( $post_type );
    1050                 $post_id = self::factory()->post->create( array(
    1051                         'post_author' => self::$editor_id,
    1052                         'post_status' => 'public',
    1053                         'post_content' => rand_str(),
    1054                         'post_title' => rand_str(),
    1055                         'post_type' => $post_type,
    1056                 ) );
    1057                 $post = get_post( $post_id );
     1094                $post_id = self::factory()->post->create(
     1095                        array(
     1096                                'post_author'  => self::$editor_id,
     1097                                'post_status'  => 'public',
     1098                                'post_content' => rand_str(),
     1099                                'post_title'   => rand_str(),
     1100                                'post_type'    => $post_type,
     1101                        )
     1102                );
     1103                $post    = get_post( $post_id );
    10581104
    10591105                $this->assertEquals( 'closed', $post->comment_status );
    … …  
    10771123
    10781124                // Create a sticky post.
    1079                 $post = self::factory()->post->create_and_get( array(
    1080                         'post_title'   => 'Will be changed',
    1081                         'post_content' => 'Will be changed',
    1082                 ) );
     1125                $post = self::factory()->post->create_and_get(
     1126                        array(
     1127                                'post_title'   => 'Will be changed',
     1128                                'post_content' => 'Will be changed',
     1129                        )
     1130                );
    10831131                stick_post( $post->ID );
    10841132
    … …  
    10871135
    10881136                // Edit the post.
    1089                 $post->post_title = 'Updated';
     1137                $post->post_title   = 'Updated';
    10901138                $post->post_content = 'Updated';
    10911139                wp_update_post( $post );
    … …  
    11061154        function test_user_without_publish_cannot_affect_sticky_with_edit_post() {
    11071155                // Create a sticky post.
    1108                 $post = self::factory()->post->create_and_get( array(
    1109                         'post_title'   => 'Will be changed',
    1110                         'post_content' => 'Will be changed',
    1111                 ) );
     1156                $post = self::factory()->post->create_and_get(
     1157                        array(
     1158                                'post_title'   => 'Will be changed',
     1159                                'post_content' => 'Will be changed',
     1160                        )
     1161                );
    11121162                stick_post( $post->ID );
    11131163
    … …  
    11441194        function test_hooks_fire_when_post_gets_stuck_and_unstuck() {
    11451195                $post_id = self::factory()->post->create();
    1146                 $a1 = new MockAction();
    1147                 $a2 = new MockAction();
     1196                $a1      = new MockAction();
     1197                $a2      = new MockAction();
    11481198
    11491199                $this->assertFalse( is_sticky( $post_id ) );
    … …  
    11711221         */
    11721222        function test_post_updates_without_slug_provided() {
    1173                 $post_id = self::factory()->post->create( array(
    1174                         'post_title'   => 'Stuff',
    1175                         'post_status'  => 'publish'
    1176                 ) );
     1223                $post_id = self::factory()->post->create(
     1224                        array(
     1225                                'post_title'  => 'Stuff',
     1226                                'post_status' => 'publish',
     1227                        )
     1228                );
    11771229
    11781230                $data = array(
    11791231                        'ID'         => $post_id,
    1180                         'post_title' => 'Stuff and Things'
     1232                        'post_title' => 'Stuff and Things',
    11811233                );
    11821234
    … …  
    11851237                $updated_post = get_post( $post_id );
    11861238                // Ensure changing the post_title didn't modify the post_name.
    1187                 $this->assertEquals('stuff', $updated_post->post_name);
     1239                $this->assertEquals( 'stuff', $updated_post->post_name );
    11881240        }
    11891241
    … …  
    12111263        function test_wp_insert_post_should_respect_post_date_gmt() {
    12121264                $post = array(
    1213                         'post_author' => self::$editor_id,
    1214                         'post_status' => 'publish',
    1215                         'post_content' => rand_str(),
    1216                         'post_title' => rand_str(),
     1265                        'post_author'   => self::$editor_id,
     1266                        'post_status'   => 'publish',
     1267                        'post_content'  => rand_str(),
     1268                        'post_title'    => rand_str(),
    12171269                        'post_date_gmt' => '2014-01-01 12:00:00',
    12181270                );
    12191271
    12201272                // insert a post and make sure the ID is ok
    1221                 $id = wp_insert_post($post);
    1222 
    1223                 $out = get_post($id);
    1224 
    1225                 $this->assertEquals($post['post_content'], $out->post_content);
    1226                 $this->assertEquals($post['post_title'], $out->post_title);
    1227                 $this->assertEquals($post['post_author'], $out->post_author);
    1228                 $this->assertEquals(get_date_from_gmt($post['post_date_gmt']), $out->post_date);
    1229                 $this->assertEquals($post['post_date_gmt'], $out->post_date_gmt);
     1273                $id = wp_insert_post( $post );
     1274
     1275                $out = get_post( $id );
     1276
     1277                $this->assertEquals( $post['post_content'], $out->post_content );
     1278                $this->assertEquals( $post['post_title'], $out->post_title );
     1279                $this->assertEquals( $post['post_author'], $out->post_author );
     1280                $this->assertEquals( get_date_from_gmt( $post['post_date_gmt'] ), $out->post_date );
     1281                $this->assertEquals( $post['post_date_gmt'], $out->post_date_gmt );
    12301282        }
    12311283
    12321284        function test_wp_delete_post_reassign_hierarchical_post_type() {
    12331285                $grandparent_page_id = self::factory()->post->create( array( 'post_type' => 'page' ) );
    1234                 $parent_page_id = self::factory()->post->create( array( 'post_type' => 'page', 'post_parent' => $grandparent_page_id ) );
    1235                 $page_id = self::factory()->post->create( array( 'post_type' => 'page', 'post_parent' => $parent_page_id ) );
     1286                $parent_page_id      = self::factory()->post->create(
     1287                        array(
     1288                                'post_type'   => 'page',
     1289                                'post_parent' => $grandparent_page_id,
     1290                        )
     1291                );
     1292                $page_id             = self::factory()->post->create(
     1293                        array(
     1294                                'post_type'   => 'page',
     1295                                'post_parent' => $parent_page_id,
     1296                        )
     1297                );
    12361298                $this->assertEquals( $parent_page_id, get_post( $page_id )->post_parent );
    12371299                wp_delete_post( $parent_page_id, true );
    … …  
    12591321                wp_set_current_user( $this->factory()->user->create( array( 'role' => 'contributor' ) ) );
    12601322
    1261                 $uuid = wp_generate_uuid4();
    1262                 $post_id = wp_insert_post( array(
    1263                         'post_type' => 'customize_changeset',
    1264                         'post_name' => strtoupper( $uuid ),
    1265                         'post_content' => wp_json_encode( $changeset_data ),
    1266                 ) );
     1323                $uuid    = wp_generate_uuid4();
     1324                $post_id = wp_insert_post(
     1325                        array(
     1326                                'post_type'    => 'customize_changeset',
     1327                                'post_name'    => strtoupper( $uuid ),
     1328                                'post_content' => wp_json_encode( $changeset_data ),
     1329                        )
     1330                );
    12671331                $this->assertEquals( $uuid, get_post( $post_id )->post_name, 'Expected lower-case UUID4 to be inserted.' );
    12681332                $this->assertEquals( $changeset_data, json_decode( get_post( $post_id )->post_content, true ) );
    12691333
    12701334                $changeset_data['blogname']['value'] = 'Hola Mundo';
    1271                 wp_update_post( array(
    1272                         'ID' => $post_id,
    1273                         'post_status' => 'draft',
    1274                         'post_content' => wp_json_encode( $changeset_data ),
    1275                 ) );
     1335                wp_update_post(
     1336                        array(
     1337                                'ID'           => $post_id,
     1338                                'post_status'  => 'draft',
     1339                                'post_content' => wp_json_encode( $changeset_data ),
     1340                        )
     1341                );
    12761342                $this->assertEquals( $uuid, get_post( $post_id )->post_name, 'Expected post_name to not have been dropped for drafts.' );
    12771343                $this->assertEquals( $changeset_data, json_decode( get_post( $post_id )->post_content, true ) );
    12781344
    12791345                $changeset_data['blogname']['value'] = 'Hallo Welt';
    1280                 wp_update_post( array(
    1281                         'ID' => $post_id,
    1282                         'post_status' => 'pending',
    1283                         'post_content' => wp_json_encode( $changeset_data ),
    1284                 ) );
     1346                wp_update_post(
     1347                        array(
     1348                                'ID'           => $post_id,
     1349                                'post_status'  => 'pending',
     1350                                'post_content' => wp_json_encode( $changeset_data ),
     1351                        )
     1352                );
    12851353                $this->assertEquals( $uuid, get_post( $post_id )->post_name, 'Expected post_name to not have been dropped for pending.' );
    12861354                $this->assertEquals( $changeset_data, json_decode( get_post( $post_id )->post_content, true ) );
Note: See TracChangeset for help on using the changeset viewer.