Ticket #49693: 49693-4.patch

src/wp-includes/cron.php

@@ -220 +220 @@
         }
 
         $key = md5( serialize( $event->args ) );
+        $crons = (array) _get_cron_array();
+
+        // Skip the duplicate check if we're doing cron.
+        if ( ! wp_doing_cron() ) {
+                // Always allow 24 occurrences per interval, even if it's an event with long $interval.
+                $allowed_occurrences = 24;
+                if ( 24 < DAY_IN_SECONDS / $event->interval ) {
+                        // Set a per-day limit based on the interval
+                        $allowed_occurrences = DAY_IN_SECONDS / $event->interval;
+                }
+                $check_interval = DAY_IN_SECONDS;
+                if ( $check_interval < $event->interval ) {
+                        $check_interval = $event->interval;
+                }
+
+                $min_timestamp = $event->timestamp - ( $check_interval / 2 );
+                $max_timestamp = $event->timestamp + ( $check_interval / 2 );
+                $occurrences = 0;
+
+                foreach ( $crons as $event_timestamp => $cron ) {
+                        if ( $event_timestamp < $min_timestamp ) {
+                                continue;
+                        }
+                        if ( $event_timestamp > $max_timestamp ) {
+                                break;
+                        }
+                        if ( isset( $cron[ $event->hook ][ $key ] ) && $cron[ $event->hook ][ $key ]['interval'] === $event->interval ) {
+                                $occurrences++;
+                                continue;
+                        }
+                }
+
+                if ( $allowed_occurrences <= $occurrences ) {
+                        return false;
+                }
+        }
 
-        $crons = _get_cron_array();
         $crons[ $event->timestamp ][ $event->hook ][ $key ] = array(
                 'schedule' => $event->schedule,
                 'args'     => $event->args,
                 'interval' => $event->interval,
         );
         uksort( $crons, 'strnatcasecmp' );
+
         return _set_cron_array( $crons );
 }
 

tests/phpunit/tests/cron.php

@@ -534 +534 @@
          * @ticket 45976.
          */
         function test_get_scheduled_event_recurring() {
-                $hook     = __FUNCTION__;
-                $args     = array( 'arg1' );
-                $ts_late  = strtotime( '+30 minutes' );
-                $ts_next  = strtotime( '+3 minutes' );
-                $schedule = 'hourly';
-                $interval = HOUR_IN_SECONDS;
+                $hook         = __FUNCTION__;
+                $args         = array( 'arg1' );
+                $ts_late      = strtotime( '+30 minutes' );
+                $ts_next      = strtotime( '+3 minutes' );
+                $schedule_one = 'hourly';
+                $schedule_two = 'daily';
+                $interval_one = HOUR_IN_SECONDS;
+                $interval_two = DAY_IN_SECONDS;
 
                 $expected1 = (object) array(
                         'hook'      => $hook,
                         'timestamp' => $ts_late,
-                        'schedule'  => $schedule,
+                        'schedule'  => $schedule_one,
                         'args'      => $args,
-                        'interval'  => $interval,
+                        'interval'  => $interval_one,
                 );
 
                 $expected2 = (object) array(
                         'hook'      => $hook,
                         'timestamp' => $ts_next,
-                        'schedule'  => $schedule,
+                        'schedule'  => $schedule_two,
                         'args'      => $args,
-                        'interval'  => $interval,
+                        'interval'  => $interval_two,
                 );
 
                 // Schedule late running event.
-                wp_schedule_event( $ts_late, $schedule, $hook, $args );
+                wp_schedule_event( $ts_late, $schedule_one, $hook, $args );
                 // Schedule next running event.
-                wp_schedule_event( $ts_next, $schedule, $hook, $args );
+                wp_schedule_event( $ts_next, $schedule_two, $hook, $args );
 
                 // Late running, timestamp specified.
                 $this->assertEquals( $expected1, wp_get_scheduled_event( $hook, $args, $ts_late ) );
@@ -680 +682 @@
                 $this->assertTrue( wp_schedule_single_event( $ts2, $hook, $args ) );
                 $this->assertTrue( wp_schedule_single_event( $ts3, $hook, $args ) );
         }
+
+        /**
+         * Recurring events have a max event limiter. Make sure it's honored properly.
+         *
+         * @ticket 49693
+         */
+        function test_duplicate_recurring_event() {
+                $hook     = __FUNCTION__;
+                $args     = array( 'arg1' );
+                $schedule = 'hourly';
+
+                // Add the max number of events for an 'hourly' schedule.
+                $max_events = DAY_IN_SECONDS / HOUR_IN_SECONDS; // Hourly schedule, max events per day is 24.
+                for ( $i = 0; $i < $max_events; $i++ ) {
+                        $timestamp_next = strtotime( '+' . ( 60 + $i ) . ' minutes' );
+                        // Scheduling the same recurring event (hook and args), but with different timestamp should fail.
+                        $this->assertTrue( wp_schedule_event( $timestamp_next, $schedule, $hook, $args ) );
+                }
+                $expected = _get_cron_array();
+
+                // Scheduling the event $max_events + 1 time should fail.
+                $this->assertFalse( wp_schedule_event( strtotime( '+120 minutes' ), $schedule, $hook, $args ) );
+
+                // Check cron option is unchanged.
+                $this->assertEquals( $expected, _get_cron_array() );
+                $this->assertCount( $max_events, _get_cron_array() );
+        }
+
+        /**
+         * Recurring events that have the same hook but different args or schedule are allowed.
+         *
+         * @ticket 49693
+         */
+        function test_not_duplicate_recurring_event() {
+                $hook         = __FUNCTION__;
+                $args_one     = array( 'arg1' );
+                $args_two     = array( 'arg2' );
+                $timestamp    = strtotime( '+60 minutes' );
+                $schedule_one = 'hourly';
+                $schedule_two = 'daily';
+
+                // Schedule recurring event.
+                $this->assertNotFalse( wp_schedule_event( $timestamp, $schedule_one, $hook, $args_one ) );
+
+                // Schedule recurring event as above, but with different schedule is allowed.
+                $this->assertNotFalse( wp_schedule_event( $timestamp, $schedule_two, $hook, $args_one ) );
+
+                // Schedule recurring event as above, but with different args is allowed.
+                $this->assertNotFalse( wp_schedule_event( $timestamp, $schedule_one, $hook, $args_two ) );
+        }
+
+        /**
+         * Make sure that rescheduling still works with the recurring event limiter when running CRON.
+         *
+         * @ticket 49693
+         */
+        function test_reschedule_recurring_event() {
+                $hook   = __FUNCTION__;
+                $ts_one = strtotime( '+30 minutes' );
+
+                // Pretend CRON is running
+                add_filter( 'wp_doing_cron', '__return_true' );
+
+                // Confirm there's no events.
+                $this->assertEmpty( _get_cron_array() );
+
+                // Add an event.
+                $this->assertTrue( wp_schedule_event( $ts_one, 'hourly', $hook ) );
+
+                // Reschedule it.
+                $this->assertNotFalse( wp_reschedule_event( $ts_one, 'hourly', $hook ) );
+
+                // Make sure the original event is still there.
+                $this->assertNotFalse( wp_get_scheduled_event( $hook, array(), $ts_one ) );
+
+                // Make sure the rescheduled event is also there.
+                $this->assertEquals( 2, count( _get_cron_array() ) );
+        }
+
+        /**
+         * Make sure that the limiter applies to event rescheduling if we're not running CRON.
+         *
+         * @ticket 49693
+         */
+        function test_not_reschedule_recurring_event() {
+                $hook     = __FUNCTION__;
+                $schedule = 'hourly';
+
+                // Add the max number of events for an 'hourly' schedule.
+                $max_events = DAY_IN_SECONDS / HOUR_IN_SECONDS; // Hourly schedule, max events per day is 24.
+                for ( $i = 0; $i < $max_events; $i++ ) {
+                        $timestamp_next = strtotime( '+' . ( 60 + $i ) . ' minutes' );
+                        // Scheduling the same recurring event (hook and args), but with different timestamp should fail.
+                        $this->assertTrue( wp_schedule_event( $timestamp_next, $schedule, $hook ) );
+                }
+                $expected = _get_cron_array();
+
+                // Rescheduling the event fails because of the limiter.
+                $this->assertFalse( wp_reschedule_event( strtotime( '+120 minutes' ), $schedule, $hook ) );
+
+                // Check cron option is unchanged.
+                $this->assertEquals( $expected, _get_cron_array() );
+                $this->assertCount( $max_events, _get_cron_array() );
+        }
 }