WordPress.org
Get WordPress

Make WordPress Core

Changeset 50143


Ignore:
Timestamp:
02/02/2021 01:47:46 PM (6 years ago)
Author:
johnbillion
Message:

Cron API: Introduce a $wp_error parameter to functions that write to the cron array.

This allows the functions to return a WP_Error object containing more information in case of a problem, instead of just boolean false.

The various pre_ filters in these functions are also updated so they can return or be passed a WP_Error object.

Fixes #49961

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/wp-includes/cron.php

    r50135 r50143  
    2424 * @since 5.1.0 Return value modified to boolean indicating success or failure,
    2525 *              {@see 'pre_schedule_event'} filter added to short-circuit the function.
     26 * @since 5.7.0 The `$wp_error` parameter was added.
    2627 *
    2728 * @link https://developer.wordpress.org/reference/functions/wp_schedule_single_event/
    … …  
    3334 *                           to the callback as an individual parameter. The array keys
    3435 *                           are ignored. Default: empty array.
    35  * @return bool True if event successfully scheduled. False for failure.
    36  */
    37 function wp_schedule_single_event( $timestamp, $hook, $args = array() ) {
     36 * @param bool   $wp_error   Optional. Whether to return a WP_Error on failure. Default false.
     37 * @return bool|WP_Error True if event successfully scheduled. False or WP_Error on failure.
     38 */
     39function wp_schedule_single_event( $timestamp, $hook, $args = array(), $wp_error = false ) {
    3840        // Make sure timestamp is a positive integer.
    3941        if ( ! is_numeric( $timestamp ) || $timestamp <= 0 ) {
     42                if ( $wp_error ) {
     43                        return new WP_Error(
     44                                'invalid_timestamp',
     45                                __( 'Event timestamp must be a valid Unix timestamp.' )
     46                        );
     47                }
     48
    4049                return false;
    4150        }
    … …  
    6372         * filter to check if another plugin has disallowed the event before scheduling.
    6473         *
    65          * Return true if the event was scheduled, false if not.
     74         * Return true if the event was scheduled, false or a WP_Error if not.
    6675         *
    6776         * @since 5.1.0
    68          *
    69          * @param null|bool $pre   Value to return instead. Default null to continue adding the event.
    70          * @param stdClass  $event {
     77         * @since 5.7.0 The `$wp_error` parameter was added, and a `WP_Error` object can now be returned.
     78         *
     79         * @param null|bool|WP_Error $pre      Value to return instead. Default null to continue adding the event.
     80         * @param stdClass           $event    {
    7181         *     An object containing an event's data.
    7282         *
    … …  
    7787         *     @type int          $interval  The interval time in seconds for the schedule. Only present for recurring events.
    7888         * }
    79          */
    80         $pre = apply_filters( 'pre_schedule_event', null, $event );
     89         * @param bool               $wp_error Whether to return a WP_Error on failure.
     90         */
     91        $pre = apply_filters( 'pre_schedule_event', null, $event, $wp_error );
     92
    8193        if ( null !== $pre ) {
     94                if ( $wp_error && false === $pre ) {
     95                        return new WP_Error(
     96                                'pre_schedule_event_false',
     97                                __( 'A plugin prevented the event from being scheduled.' )
     98                        );
     99                }
     100
     101                if ( ! $wp_error && is_wp_error( $pre ) ) {
     102                        return false;
     103                }
     104
    82105                return $pre;
    83106        }
    … …  
    126149
    127150        if ( $duplicate ) {
     151                if ( $wp_error ) {
     152                        return new WP_Error(
     153                                'duplicate_event',
     154                                __( 'A duplicate event already exists.' )
     155                        );
     156                }
     157
    128158                return false;
    129159        }
    … …  
    148178        // A plugin disallowed this event.
    149179        if ( ! $event ) {
     180                if ( $wp_error ) {
     181                        return new WP_Error(
     182                                'schedule_event_false',
     183                                __( 'A plugin disallowed this event.' )
     184                        );
     185                }
     186
    150187                return false;
    151188        }
    … …  
    156193        );
    157194        uksort( $crons, 'strnatcasecmp' );
    158         return _set_cron_array( $crons );
     195
     196        return _set_cron_array( $crons, $wp_error );
    159197}
    160198
    … …  
    180218 * @since 5.1.0 Return value modified to boolean indicating success or failure,
    181219 *              {@see 'pre_schedule_event'} filter added to short-circuit the function.
     220 * @since 5.7.0 The `$wp_error` parameter was added.
    182221 *
    183222 * @link https://developer.wordpress.org/reference/functions/wp_schedule_event/
    … …  
    191230 *                           to the callback as an individual parameter. The array keys
    192231 *                           are ignored. Default: empty array.
    193  * @return bool True if event successfully scheduled. False for failure.
    194  */
    195 function wp_schedule_event( $timestamp, $recurrence, $hook, $args = array() ) {
     232 * @param bool   $wp_error   Optional. Whether to return a WP_Error on failure. Default false.
     233 * @return bool|WP_Error True if event successfully scheduled. False or WP_Error on failure.
     234 */
     235function wp_schedule_event( $timestamp, $recurrence, $hook, $args = array(), $wp_error = false ) {
    196236        // Make sure timestamp is a positive integer.
    197237        if ( ! is_numeric( $timestamp ) || $timestamp <= 0 ) {
     238                if ( $wp_error ) {
     239                        return new WP_Error(
     240                                'invalid_timestamp',
     241                                __( 'Event timestamp must be a valid Unix timestamp.' )
     242                        );
     243                }
     244
    198245                return false;
    199246        }
    … …  
    202249
    203250        if ( ! isset( $schedules[ $recurrence ] ) ) {
     251                if ( $wp_error ) {
     252                        return new WP_Error(
     253                                'invalid_schedule',
     254                                __( 'Event schedule does not exist.' )
     255                        );
     256                }
     257
    204258                return false;
    205259        }
    … …  
    214268
    215269        /** This filter is documented in wp-includes/cron.php */
    216         $pre = apply_filters( 'pre_schedule_event', null, $event );
     270        $pre = apply_filters( 'pre_schedule_event', null, $event, $wp_error );
     271
    217272        if ( null !== $pre ) {
     273                if ( $wp_error && false === $pre ) {
     274                        return new WP_Error(
     275                                'pre_schedule_event_false',
     276                                __( 'A plugin prevented the event from being scheduled.' )
     277                        );
     278                }
     279
     280                if ( ! $wp_error && is_wp_error( $pre ) ) {
     281                        return false;
     282                }
     283
    218284                return $pre;
    219285        }
    … …  
    224290        // A plugin disallowed this event.
    225291        if ( ! $event ) {
     292                if ( $wp_error ) {
     293                        return new WP_Error(
     294                                'schedule_event_false',
     295                                __( 'A plugin disallowed this event.' )
     296                        );
     297                }
     298
    226299                return false;
    227300        }
    … …  
    236309        );
    237310        uksort( $crons, 'strnatcasecmp' );
    238         return _set_cron_array( $crons );
     311
     312        return _set_cron_array( $crons, $wp_error );
    239313}
    240314
    … …  
    251325 * @since 5.1.0 Return value modified to boolean indicating success or failure,
    252326 *              {@see 'pre_reschedule_event'} filter added to short-circuit the function.
     327 * @since 5.7.0 The `$wp_error` parameter was added.
    253328 *
    254329 * @param int    $timestamp  Unix timestamp (UTC) for when the event was scheduled.
    … …  
    260335 *                           to the callback as an individual parameter. The array keys
    261336 *                           are ignored. Default: empty array.
    262  * @return bool True if event successfully rescheduled. False for failure.
    263  */
    264 function wp_reschedule_event( $timestamp, $recurrence, $hook, $args = array() ) {
     337 * @param bool   $wp_error   Optional. Whether to return a WP_Error on failure. Default false.
     338 * @return bool|WP_Error True if event successfully rescheduled. False or WP_Error on failure.
     339 */
     340function wp_reschedule_event( $timestamp, $recurrence, $hook, $args = array(), $wp_error = false ) {
    265341        // Make sure timestamp is a positive integer.
    266342        if ( ! is_numeric( $timestamp ) || $timestamp <= 0 ) {
     343                if ( $wp_error ) {
     344                        return new WP_Error(
     345                                'invalid_timestamp',
     346                                __( 'Event timestamp must be a valid Unix timestamp.' )
     347                        );
     348                }
     349
    267350                return false;
    268351        }
    … …  
    302385         *
    303386         * @since 5.1.0
    304          *
    305          * @param null|bool $pre   Value to return instead. Default null to continue adding the event.
    306          * @param stdClass  $event {
     387         * @since 5.7.0 The `$wp_error` parameter was added, and a `WP_Error` object can now be returned.
     388         *
     389         * @param null|bool|WP_Error $pre      Value to return instead. Default null to continue adding the event.
     390         * @param stdClass           $event    {
    307391         *     An object containing an event's data.
    308392         *
    … …  
    313397         *     @type int          $interval  The interval time in seconds for the schedule. Only present for recurring events.
    314398         * }
     399         * @param bool               $wp_error Whether to return a WP_Error on failure.
    315400         */
    316401        $pre = apply_filters( 'pre_reschedule_event', null, $event );
     402
    317403        if ( null !== $pre ) {
     404                if ( $wp_error && false === $pre ) {
     405                        return new WP_Error(
     406                                'pre_reschedule_event_false',
     407                                __( 'A plugin prevented the event from being rescheduled.' )
     408                        );
     409                }
     410
     411                if ( ! $wp_error && is_wp_error( $pre ) ) {
     412                        return false;
     413                }
     414
    318415                return $pre;
    319416        }
    … …  
    321418        // Now we assume something is wrong and fail to schedule.
    322419        if ( 0 == $interval ) {
     420                if ( $wp_error ) {
     421                        return new WP_Error(
     422                                'invalid_schedule',
     423                                __( 'Event schedule does not exist.' )
     424                        );
     425                }
     426
    323427                return false;
    324428        }
    … …  
    332436        }
    333437
    334         return wp_schedule_event( $timestamp, $recurrence, $hook, $args );
     438        return wp_schedule_event( $timestamp, $recurrence, $hook, $args, $wp_error );
    335439}
    336440
    … …  
    344448 * @since 5.1.0 Return value modified to boolean indicating success or failure,
    345449 *              {@see 'pre_unschedule_event'} filter added to short-circuit the function.
     450 * @since 5.7.0 The `$wp_error` parameter was added.
    346451 *
    347452 * @param int    $timestamp Unix timestamp (UTC) of the event.
    … …  
    350455 *                          Although not passed to a callback, these arguments are used to uniquely identify the
    351456 *                          event, so they should be the same as those used when originally scheduling the event.
    352  * @return bool True if event successfully unscheduled. False for failure.
    353  */
    354 function wp_unschedule_event( $timestamp, $hook, $args = array() ) {
     457 * @param bool   $wp_error  Optional. Whether to return a WP_Error on failure. Default false.
     458 * @return bool|WP_Error True if event successfully unscheduled. False or WP_Error on failure.
     459 */
     460function wp_unschedule_event( $timestamp, $hook, $args = array(), $wp_error = false ) {
    355461        // Make sure timestamp is a positive integer.
    356462        if ( ! is_numeric( $timestamp ) || $timestamp <= 0 ) {
     463                if ( $wp_error ) {
     464                        return new WP_Error(
     465                                'invalid_timestamp',
     466                                __( 'Event timestamp must be a valid Unix timestamp.' )
     467                        );
     468                }
     469
    357470                return false;
    358471        }
    … …  
    368481         *
    369482         * @since 5.1.0
    370          *
    371          * @param null|bool $pre       Value to return instead. Default null to continue unscheduling the event.
    372          * @param int       $timestamp Timestamp for when to run the event.
    373          * @param string    $hook      Action hook, the execution of which will be unscheduled.
    374          * @param array     $args      Arguments to pass to the hook's callback function.
    375          */
    376         $pre = apply_filters( 'pre_unschedule_event', null, $timestamp, $hook, $args );
     483         * @since 5.7.0 The `$wp_error` parameter was added, and a `WP_Error` object can now be returned.
     484         *
     485         * @param null|bool|WP_Error $pre       Value to return instead. Default null to continue unscheduling the event.
     486         * @param int                $timestamp Timestamp for when to run the event.
     487         * @param string             $hook      Action hook, the execution of which will be unscheduled.
     488         * @param array              $args      Arguments to pass to the hook's callback function.
     489         * @param bool               $wp_error  Whether to return a WP_Error on failure.
     490         */
     491        $pre = apply_filters( 'pre_unschedule_event', null, $timestamp, $hook, $args, $wp_error );
     492
    377493        if ( null !== $pre ) {
     494                if ( $wp_error && false === $pre ) {
     495                        return new WP_Error(
     496                                'pre_unschedule_event_false',
     497                                __( 'A plugin prevented the event from being unscheduled.' )
     498                        );
     499                }
     500
     501                if ( ! $wp_error && is_wp_error( $pre ) ) {
     502                        return false;
     503                }
     504
    378505                return $pre;
    379506        }
    … …  
    388515                unset( $crons[ $timestamp ] );
    389516        }
    390         return _set_cron_array( $crons );
     517
     518        return _set_cron_array( $crons, $wp_error );
    391519}
    392520
    … …  
    407535 *                     Although not passed to a callback, these arguments are used to uniquely identify the
    408536 *                     event, so they should be the same as those used when originally scheduling the event.
    409  * @return int|false On success an integer indicating number of events unscheduled (0 indicates no
    410  *                   events were registered with the hook and arguments combination), false if
    411  *                   unscheduling one or more events fail.
    412  */
    413 function wp_clear_scheduled_hook( $hook, $args = array() ) {
     537 * @param bool   $wp_error  Optional. Whether to return a WP_Error on failure. Default false.
     538 * @return int|false|WP_Error On success an integer indicating number of events unscheduled (0 indicates no
     539 *                            events were registered with the hook and arguments combination), false or WP_Error
     540 *                            if unscheduling one or more events fail.
     541 */
     542function wp_clear_scheduled_hook( $hook, $args = array(), $wp_error = false ) {
    414543        // Backward compatibility.
    415544        // Previously, this function took the arguments as discrete vars rather than an array like the rest of the API.
    … …  
    417546                _deprecated_argument( __FUNCTION__, '3.0.0', __( 'This argument has changed to an array to match the behavior of the other cron functions.' ) );
    418547                $args = array_slice( func_get_args(), 1 ); // phpcs:ignore PHPCompatibility.FunctionUse.ArgumentFunctionsReportCurrentValue.NeedsInspection
     548                $wp_error = false;
    419549        }
    420550
    … …  
    430560         *
    431561         * @since 5.1.0
    432          *
    433          * @param null|int|false $pre  Value to return instead. Default null to continue unscheduling the event.
    434          * @param string         $hook Action hook, the execution of which will be unscheduled.
    435          * @param array          $args Arguments to pass to the hook's callback function.
    436          */
    437         $pre = apply_filters( 'pre_clear_scheduled_hook', null, $hook, $args );
     562         * @since 5.7.0 The `$wp_error` parameter was added, and a `WP_Error` object can now be returned.
     563         *
     564         * @param null|int|false|WP_Error $pre      Value to return instead. Default null to continue unscheduling the event.
     565         * @param string                  $hook     Action hook, the execution of which will be unscheduled.
     566         * @param array                   $args     Arguments to pass to the hook's callback function.
     567         * @param bool                    $wp_error Whether to return a WP_Error on failure.
     568         */
     569        $pre = apply_filters( 'pre_clear_scheduled_hook', null, $hook, $args, $wp_error );
     570
    438571        if ( null !== $pre ) {
     572                if ( $wp_error && false === $pre ) {
     573                        return new WP_Error(
     574                                'pre_clear_scheduled_hook_false',
     575                                __( 'A plugin prevented the hook from being cleared.' )
     576                        );
     577                }
     578
     579                if ( ! $wp_error && is_wp_error( $pre ) ) {
     580                        return false;
     581                }
     582
    439583                return $pre;
    440584        }
    … …  
    452596        $results = array();
    453597        $key     = md5( serialize( $args ) );
     598
    454599        foreach ( $crons as $timestamp => $cron ) {
    455600                if ( isset( $cron[ $hook ][ $key ] ) ) {
    456                         $results[] = wp_unschedule_event( $timestamp, $hook, $args );
    457                 }
    458         }
    459         if ( in_array( false, $results, true ) ) {
    460                 return false;
    461         }
     601                        $results[] = wp_unschedule_event( $timestamp, $hook, $args, true );
     602                }
     603        }
     604
     605        $errors = array_filter( $results, 'is_wp_error' );
     606        $error  = new WP_Error();
     607
     608        if ( $errors ) {
     609                if ( $wp_error ) {
     610                        array_walk( $errors, array( $error, 'merge_from' ) );
     611
     612                        return $error;
     613                }
     614
     615                return false;
     616        }
     617
    462618        return count( $results );
    463619}
    … …  
    475631 * @since 4.9.0
    476632 * @since 5.1.0 Return value added to indicate success or failure.
    477  *
    478  * @param string $hook Action hook, the execution of which will be unscheduled.
    479  * @return int|false On success an integer indicating number of events unscheduled (0 indicates no
    480  *                   events were registered on the hook), false if unscheduling fails.
    481  */
    482 function wp_unschedule_hook( $hook ) {
     633 * @since 5.7.0 The `$wp_error` parameter was added.
     634 *
     635 * @param string $hook     Action hook, the execution of which will be unscheduled.
     636 * @param bool   $wp_error Optional. Whether to return a WP_Error on failure. Default false.
     637 * @return int|false|WP_Error On success an integer indicating number of events unscheduled (0 indicates no
     638 *                            events were registered on the hook), false or WP_Error if unscheduling fails.
     639 */
     640function wp_unschedule_hook( $hook, $wp_error = false ) {
    483641        /**
    484642         * Filter to preflight or hijack clearing all events attached to the hook.
    … …  
    492650         *
    493651         * @since 5.1.0
    494          *
    495          * @param null|int|false $pre  Value to return instead. Default null to continue unscheduling the hook.
    496          * @param string         $hook Action hook, the execution of which will be unscheduled.
    497          */
    498         $pre = apply_filters( 'pre_unschedule_hook', null, $hook );
     652         * @since 5.7.0 The `$wp_error` parameter was added, and a `WP_Error` object can now be returned.
     653         *
     654         * @param null|int|false|WP_Error $pre      Value to return instead. Default null to continue unscheduling the hook.
     655         * @param string                  $hook     Action hook, the execution of which will be unscheduled.
     656         * @param bool                    $wp_error Whether to return a WP_Error on failure.
     657         */
     658        $pre = apply_filters( 'pre_unschedule_hook', null, $hook, $wp_error );
     659
    499660        if ( null !== $pre ) {
     661                if ( $wp_error && false === $pre ) {
     662                        return new WP_Error(
     663                                'pre_unschedule_hook_false',
     664                                __( 'A plugin prevented the hook from being cleared.' )
     665                        );
     666                }
     667
     668                if ( ! $wp_error && is_wp_error( $pre ) ) {
     669                        return false;
     670                }
     671
    500672                return $pre;
    501673        }
    … …  
    525697                return 0;
    526698        }
    527         if ( _set_cron_array( $crons ) ) {
     699
     700        $set = _set_cron_array( $crons, $wp_error );
     701
     702        if ( true === $set ) {
    528703                return array_sum( $results );
    529704        }
    530         return false;
     705
     706        return $set;
    531707}
    532708
    … …  
    9931169
    9941170/**
    995  * Updates the CRON option with the new CRON array.
     1171 * Updates the cron option with the new cron array.
    9961172 *
    9971173 * @since 2.1.0
    9981174 * @since 5.1.0 Return value modified to outcome of update_option().
     1175 * @since 5.7.0 The `$wp_error` parameter was added.
    9991176 *
    10001177 * @access private
    10011178 *
    1002  * @param array $cron Cron info array from _get_cron_array().
    1003  * @return bool True if cron array updated, false on failure.
    1004  */
    1005 function _set_cron_array( $cron ) {
     1179 * @param array $cron     Cron info array from _get_cron_array().
     1180 * @param bool  $wp_error Optional. Whether to return a WP_Error on failure. Default false.
     1181 * @return bool|WP_Error True if cron array updated. False or WP_Error on failure.
     1182 */
     1183function _set_cron_array( $cron, $wp_error = false ) {
    10061184        $cron['version'] = 2;
    1007         return update_option( 'cron', $cron );
     1185        $result = update_option( 'cron', $cron );
     1186
     1187        if ( $wp_error && ! $result ) {
     1188                return new WP_Error(
     1189                        'could_not_set',
     1190                        __( 'The cron event list could not be saved.' )
     1191                );
     1192        }
     1193
     1194        return $result;
    10081195}
    10091196

  • trunk/tests/phpunit/tests/cron.php

    r48937 r50143  
    272272                // First one works.
    273273                $this->assertTrue( wp_schedule_single_event( $ts1, $hook, $args ) );
    274                 // Second one is ignored.
     274
     275                // Subsequent ones are ignored.
    275276                $this->assertFalse( wp_schedule_single_event( $ts2, $hook, $args ) );
     277                $subsequent = wp_schedule_single_event( $ts2, $hook, $args, true );
     278                $this->assertWPError( $subsequent );
     279                $this->assertSame( 'duplicate_event', $subsequent->get_error_code() );
    276280
    277281                // The next event should be at +5 minutes, not +3.
    … …  
    618622                // Third event fails.
    619623                $this->assertFalse( wp_schedule_single_event( $ts3, $hook, $args ) );
     624
     625                // Fourth event fails.
     626                $subsequent = wp_schedule_single_event( $ts3, $hook, $args, true );
     627                $this->assertWPError( $subsequent );
     628                $this->assertSame( 'duplicate_event', $subsequent->get_error_code() );
    620629        }
    621630
    … …  
    640649                // Third event fails.
    641650                $this->assertFalse( wp_schedule_single_event( $ts3, $hook, $args ) );
     651
     652                // Fourth event fails.
     653                $subsequent = wp_schedule_single_event( $ts3, $hook, $args, true );
     654                $this->assertWPError( $subsequent );
     655                $this->assertSame( 'duplicate_event', $subsequent->get_error_code() );
     656
    642657        }
    643658
    … …  
    660675                $this->assertFalse( wp_schedule_single_event( $ts2, $hook, $args ) );
    661676                $this->assertFalse( wp_schedule_single_event( $ts3, $hook, $args ) );
     677
     678                $subsequent = wp_schedule_single_event( $ts3, $hook, $args, true );
     679                $this->assertWPError( $subsequent );
     680                $this->assertSame( 'duplicate_event', $subsequent->get_error_code() );
    662681        }
    663682
    … …  
    681700                $this->assertTrue( wp_schedule_single_event( $ts3, $hook, $args ) );
    682701        }
     702
     703        /**
     704         * @ticket 49961
     705         */
     706        public function test_invalid_timestamp_for_event_returns_error() {
     707                $single_event      = wp_schedule_single_event( -50, 'hook', array(), true );
     708                $event             = wp_schedule_event( -50, 'daily', 'hook', array(), true );
     709                $rescheduled_event = wp_reschedule_event( -50, 'daily', 'hook', array(), true );
     710                $unscheduled_event = wp_unschedule_event( -50, 'hook', array(), true );
     711
     712                $this->assertWPError( $single_event );
     713                $this->assertSame( 'invalid_timestamp', $single_event->get_error_code() );
     714
     715                $this->assertWPError( $event );
     716                $this->assertSame( 'invalid_timestamp', $event->get_error_code() );
     717
     718                $this->assertWPError( $rescheduled_event );
     719                $this->assertSame( 'invalid_timestamp', $rescheduled_event->get_error_code() );
     720
     721                $this->assertWPError( $unscheduled_event );
     722                $this->assertSame( 'invalid_timestamp', $unscheduled_event->get_error_code() );
     723        }
     724
     725        /**
     726         * @ticket 49961
     727         */
     728        public function test_invalid_recurrence_for_event_returns_error() {
     729                $event             = wp_schedule_event( time(), 'invalid', 'hook', array(), true );
     730                $rescheduled_event = wp_reschedule_event( time(), 'invalid', 'hook', array(), true );
     731
     732                $this->assertWPError( $event );
     733                $this->assertSame( 'invalid_schedule', $event->get_error_code() );
     734
     735                $this->assertWPError( $rescheduled_event );
     736                $this->assertSame( 'invalid_schedule', $rescheduled_event->get_error_code() );
     737        }
     738
     739        /**
     740         * @ticket 49961
     741         */
     742        public function test_disallowed_event_returns_false_when_wp_error_is_set_to_false() {
     743                add_filter( 'schedule_event', '__return_false' );
     744
     745                $single_event      = wp_schedule_single_event( time(), 'hook', array() );
     746                $event             = wp_schedule_event( time(), 'daily', 'hook', array() );
     747                $rescheduled_event = wp_reschedule_event( time(), 'daily', 'hook', array() );
     748
     749                $this->assertFalse( $single_event );
     750                $this->assertFalse( $event );
     751                $this->assertFalse( $rescheduled_event );
     752        }
     753
     754        /**
     755         * @ticket 49961
     756         */
     757        public function test_disallowed_event_returns_error_when_wp_error_is_set_to_true() {
     758                add_filter( 'schedule_event', '__return_false' );
     759
     760                $single_event      = wp_schedule_single_event( time(), 'hook', array(), true );
     761                $event             = wp_schedule_event( time(), 'daily', 'hook', array(), true );
     762                $rescheduled_event = wp_reschedule_event( time(), 'daily', 'hook', array(), true );
     763
     764                $this->assertWPError( $single_event );
     765                $this->assertSame( 'schedule_event_false', $single_event->get_error_code() );
     766
     767                $this->assertWPError( $event );
     768                $this->assertSame( 'schedule_event_false', $event->get_error_code() );
     769
     770                $this->assertWPError( $rescheduled_event );
     771                $this->assertSame( 'schedule_event_false', $rescheduled_event->get_error_code() );
     772        }
     773
     774        /**
     775         * @ticket 49961
     776         */
     777        public function test_schedule_short_circuit_with_error_returns_false_when_wp_error_is_set_to_false() {
     778                $return_error = function() {
     779                        return new WP_Error(
     780                                'my_error',
     781                                'An error ocurred'
     782                        );
     783                };
     784
     785                // Add filters which return a WP_Error:
     786                add_filter( 'pre_schedule_event', $return_error );
     787                add_filter( 'pre_reschedule_event', $return_error );
     788
     789                // Schedule events without the `$wp_error` parameter:
     790                $single_event      = wp_schedule_single_event( time(), 'hook', array() );
     791                $event             = wp_schedule_event( time(), 'daily', 'hook', array() );
     792                $rescheduled_event = wp_reschedule_event( time(), 'daily', 'hook', array() );
     793
     794                // Ensure boolean false is returned:
     795                $this->assertFalse( $single_event );
     796                $this->assertFalse( $event );
     797                $this->assertFalse( $rescheduled_event );
     798        }
     799
     800        /**
     801         * @ticket 49961
     802         */
     803        public function test_schedule_short_circuit_with_error_returns_error_when_wp_error_is_set_to_true() {
     804                $return_error = function() {
     805                        return new WP_Error(
     806                                'my_error',
     807                                'An error ocurred'
     808                        );
     809                };
     810
     811                // Add filters which return a WP_Error:
     812                add_filter( 'pre_schedule_event', $return_error );
     813                add_filter( 'pre_reschedule_event', $return_error );
     814
     815                // Schedule events with the `$wp_error` parameter:
     816                $single_event      = wp_schedule_single_event( time(), 'hook', array(), true );
     817                $event             = wp_schedule_event( time(), 'daily', 'hook', array(), true );
     818                $rescheduled_event = wp_reschedule_event( time(), 'daily', 'hook', array(), true );
     819
     820                // Ensure the error object is returned:
     821                $this->assertWPError( $single_event );
     822                $this->assertSame( 'my_error', $single_event->get_error_code() );
     823
     824                $this->assertWPError( $event );
     825                $this->assertSame( 'my_error', $event->get_error_code() );
     826
     827                $this->assertWPError( $rescheduled_event );
     828                $this->assertSame( 'my_error', $rescheduled_event->get_error_code() );
     829        }
     830
     831        /**
     832         * @ticket 49961
     833         */
     834        public function test_schedule_short_circuit_with_false_returns_false_when_wp_error_is_set_to_false() {
     835                // Add filters which return false:
     836                add_filter( 'pre_schedule_event', '__return_false' );
     837                add_filter( 'pre_reschedule_event', '__return_false' );
     838
     839                // Schedule events without the `$wp_error` parameter:
     840                $single_event      = wp_schedule_single_event( time(), 'hook', array() );
     841                $event             = wp_schedule_event( time(), 'daily', 'hook', array() );
     842                $rescheduled_event = wp_reschedule_event( time(), 'daily', 'hook', array() );
     843
     844                // Ensure false is returned:
     845                $this->assertFalse( $single_event );
     846                $this->assertFalse( $event );
     847                $this->assertFalse( $rescheduled_event );
     848        }
     849
     850        /**
     851         * @ticket 49961
     852         */
     853        public function test_schedule_short_circuit_with_false_returns_error_when_wp_error_is_set_to_true() {
     854                // Add filters which return false:
     855                add_filter( 'pre_schedule_event', '__return_false' );
     856                add_filter( 'pre_reschedule_event', '__return_false' );
     857
     858                // Schedule events with the `$wp_error` parameter:
     859                $single_event      = wp_schedule_single_event( time(), 'hook', array(), true );
     860                $event             = wp_schedule_event( time(), 'daily', 'hook', array(), true );
     861                $rescheduled_event = wp_reschedule_event( time(), 'daily', 'hook', array(), true );
     862
     863                // Ensure an error object is returned:
     864                $this->assertWPError( $single_event );
     865                $this->assertSame( 'pre_schedule_event_false', $single_event->get_error_code() );
     866
     867                $this->assertWPError( $event );
     868                $this->assertSame( 'pre_schedule_event_false', $event->get_error_code() );
     869
     870                $this->assertWPError( $rescheduled_event );
     871                $this->assertSame( 'pre_reschedule_event_false', $rescheduled_event->get_error_code() );
     872        }
     873
     874        /**
     875         * @ticket 49961
     876         * @expectedDeprecated wp_clear_scheduled_hook
     877         */
     878        public function test_deprecated_argument_usage_of_wp_clear_scheduled_hook() {
     879                add_filter(
     880                        'pre_clear_scheduled_hook',
     881                        function( $pre, $hook, $args, $wp_error ) {
     882                                $this->assertSame( array( 1, 2, 3 ), $args );
     883                                $this->assertFalse( $wp_error );
     884
     885                                return $pre;
     886                        },
     887                        10,
     888                        4
     889                );
     890
     891                $cleared = wp_clear_scheduled_hook( 'hook', 1, 2, 3 );
     892
     893                $this->assertSame( 0, $cleared );
     894        }
     895
     896        /**
     897         * @ticket 49961
     898         */
     899        public function test_clear_scheduled_hook_returns_default_pre_filter_error_when_wp_error_is_set_to_true() {
     900                add_filter( 'pre_unschedule_event', '__return_false' );
     901
     902                wp_schedule_single_event( strtotime( '+1 hour' ), 'test_hook' );
     903                wp_schedule_single_event( strtotime( '+2 hours' ), 'test_hook' );
     904
     905                $cleared = wp_clear_scheduled_hook( 'test_hook', array(), true );
     906
     907                $this->assertWPError( $cleared );
     908                $this->assertSame(
     909                        array(
     910                                'pre_unschedule_event_false',
     911                        ),
     912                        $cleared->get_error_codes()
     913                );
     914                $this->assertCount( 2, $cleared->get_error_messages() );
     915        }
     916
     917        /**
     918         * @ticket 49961
     919         */
     920        public function test_clear_scheduled_hook_returns_custom_pre_filter_error_when_wp_error_is_set_to_true() {
     921                add_filter(
     922                        'pre_unschedule_event',
     923                        function( $pre ) {
     924                                return new WP_Error( 'error_code', 'error message' );
     925                        }
     926                );
     927
     928                wp_schedule_single_event( strtotime( '+1 hour' ), 'test_hook' );
     929                wp_schedule_single_event( strtotime( '+2 hours' ), 'test_hook' );
     930
     931                $cleared = wp_clear_scheduled_hook( 'test_hook', array(), true );
     932
     933                $this->assertWPError( $cleared );
     934                $this->assertSame(
     935                        array(
     936                                'error_code',
     937                        ),
     938                        $cleared->get_error_codes()
     939                );
     940                $this->assertSame(
     941                        array(
     942                                'error message',
     943                                'error message',
     944                        ),
     945                        $cleared->get_error_messages()
     946                );
     947        }
     948
     949        /**
     950         * @ticket 49961
     951         */
     952        public function test_unschedule_short_circuit_with_error_returns_false_when_wp_error_is_set_to_false() {
     953                $return_error = function() {
     954                        return new WP_Error(
     955                                'my_error',
     956                                'An error ocurred'
     957                        );
     958                };
     959
     960                // Add a filter which returns a WP_Error:
     961                add_filter( 'pre_unschedule_hook', $return_error );
     962
     963                // Unschedule a hook without the `$wp_error` parameter:
     964                $result = wp_unschedule_hook( 'hook' );
     965
     966                // Ensure boolean false is returned:
     967                $this->assertFalse( $result );
     968        }
     969
     970        /**
     971         * @ticket 49961
     972         */
     973        public function test_unschedule_short_circuit_with_error_returns_error_when_wp_error_is_set_to_true() {
     974                $return_error = function() {
     975                        return new WP_Error(
     976                                'my_error',
     977                                'An error ocurred'
     978                        );
     979                };
     980
     981                // Add a filter which returns a WP_Error:
     982                add_filter( 'pre_unschedule_hook', $return_error );
     983
     984                // Unschedule a hook with the `$wp_error` parameter:
     985                $result = wp_unschedule_hook( 'hook', true );
     986
     987                // Ensure the error object is returned:
     988                $this->assertWPError( $result );
     989                $this->assertSame( 'my_error', $result->get_error_code() );
     990        }
     991
     992        /**
     993         * @ticket 49961
     994         */
     995        public function test_unschedule_short_circuit_with_false_returns_false_when_wp_error_is_set_to_false() {
     996                // Add a filter which returns false:
     997                add_filter( 'pre_unschedule_hook', '__return_false' );
     998
     999                // Unschedule a hook without the `$wp_error` parameter:
     1000                $result = wp_unschedule_hook( 'hook' );
     1001
     1002                // Ensure false is returned:
     1003                $this->assertFalse( $result );
     1004        }
     1005
     1006        /**
     1007         * @ticket 49961
     1008         */
     1009        public function test_unschedule_short_circuit_with_false_returns_error_when_wp_error_is_set_to_true() {
     1010                // Add a filter which returns false:
     1011                add_filter( 'pre_unschedule_hook', '__return_false' );
     1012
     1013                // Unchedule a hook with the `$wp_error` parameter:
     1014                $result = wp_unschedule_hook( 'hook', true );
     1015
     1016                // Ensure an error object is returned:
     1017                $this->assertWPError( $result );
     1018                $this->assertSame( 'pre_unschedule_hook_false', $result->get_error_code() );
     1019        }
     1020
     1021        /**
     1022         * @ticket 49961
     1023         */
     1024        public function test_cron_array_error_is_returned_when_scheduling_single_event() {
     1025                // Force update_option() to fail by setting the new value to match the existing:
     1026                add_filter(
     1027                        'pre_update_option_cron',
     1028                        function() {
     1029                                return get_option( 'cron' );
     1030                        }
     1031                );
     1032
     1033                // Attempt to schedule a valid event:
     1034                $event = wp_schedule_single_event( time(), 'hook', array(), true );
     1035
     1036                // Ensure an error object is returned:
     1037                $this->assertWPError( $event );
     1038                $this->assertSame( 'could_not_set', $event->get_error_code() );
     1039        }
     1040
     1041        /**
     1042         * @ticket 49961
     1043         */
     1044        public function test_cron_array_error_is_returned_when_scheduling_event() {
     1045                // Force update_option() to fail by setting the new value to match the existing:
     1046                add_filter(
     1047                        'pre_update_option_cron',
     1048                        function() {
     1049                                return get_option( 'cron' );
     1050                        }
     1051                );
     1052
     1053                // Attempt to schedule a valid event:
     1054                $event = wp_schedule_event( time(), 'daily', 'hook', array(), true );
     1055
     1056                // Ensure an error object is returned:
     1057                $this->assertWPError( $event );
     1058                $this->assertSame( 'could_not_set', $event->get_error_code() );
     1059        }
     1060
     1061        /**
     1062         * @ticket 49961
     1063         */
     1064        public function test_cron_array_error_is_returned_when_unscheduling_hook() {
     1065                // Schedule a valid event:
     1066                $event = wp_schedule_event( strtotime( '+1 hour' ), 'daily', 'hook', array(), true );
     1067
     1068                // Force update_option() to fail by setting the new value to match the existing:
     1069                add_filter(
     1070                        'pre_update_option_cron',
     1071                        function() {
     1072                                return get_option( 'cron' );
     1073                        }
     1074                );
     1075
     1076                // Attempt to unschedule the hook:
     1077                $unscheduled = wp_unschedule_hook( 'hook', true );
     1078
     1079                // Ensure an error object is returned:
     1080                $this->assertTrue( $event );
     1081                $this->assertWPError( $unscheduled );
     1082                $this->assertSame( 'could_not_set', $unscheduled->get_error_code() );
     1083        }
     1084
     1085        /**
     1086         * @ticket 49961
     1087         */
     1088        public function test_cron_array_error_is_returned_when_unscheduling_event() {
     1089                // Schedule a valid event:
     1090                $event = wp_schedule_event( strtotime( '+1 hour' ), 'daily', 'hook', array(), true );
     1091
     1092                // Force update_option() to fail by setting the new value to match the existing:
     1093                add_filter(
     1094                        'pre_update_option_cron',
     1095                        function() {
     1096                                return get_option( 'cron' );
     1097                        }
     1098                );
     1099
     1100                // Attempt to unschedule the event:
     1101                $unscheduled = wp_unschedule_event( wp_next_scheduled( 'hook' ), 'hook', array(), true );
     1102
     1103                // Ensure an error object is returned:
     1104                $this->assertTrue( $event );
     1105                $this->assertWPError( $unscheduled );
     1106                $this->assertSame( 'could_not_set', $unscheduled->get_error_code() );
     1107        }
     1108
    6831109}
Note: See TracChangeset for help on using the changeset viewer.