WebSVN – Moodle – Diff – /lib/tests/task/adhoc_task_test.php

 // You should have received a copy of the GNU General Public License
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+namespace core\task;
-namespace core\task;
+use core\url;
 /**
  * Test class for adhoc tasks.
+ *
      * Test basic adhoc task execution.
      */
     public function test_get_next_adhoc_task_now(): void {
         $this->resetAfterTest(true);
+        $clock = $this->mock_clock_with_frozen();
         // Create an adhoc task.
         $task = new adhoc_test_task();
-        // Queue it.
-        manager::queue_adhoc_task($task);
+        // Queue it.
+        manager::queue_adhoc_task($task);
         $now = time();
         // Get it from the scheduler.
-        $task = manager::get_next_adhoc_task($now);
+        $task = manager::get_next_adhoc_task($clock->time());
         $this->assertInstanceOf('\\core\\task\\adhoc_test_task', $task);
      * Test basic adhoc task execution.
      */
     public function test_get_next_adhoc_task_class(): void {
         $this->resetAfterTest(true);
+        $clock = $this->mock_clock_with_frozen();
         // Create an adhoc task.
         $task = new \core\task\adhoc_test_task();
-        // Queue it.
-        manager::queue_adhoc_task($task);
+        // Queue it.
         manager::queue_adhoc_task($task);
-        $now = time();
         $classname = get_class($task);
         // The task will not be returned.
-        $this->assertNull(manager::get_next_adhoc_task($now, true, "{$classname}notexists"));
+        $this->assertNull(manager::get_next_adhoc_task($clock->time(), true, "{$classname}notexists"));
         // Get it from the scheduler.
      * Test adhoc task failure retry backoff.
      */
     public function test_get_next_adhoc_task_fail_retry(): void {
         $this->resetAfterTest(true);
+        $clock = $this->mock_clock_with_frozen();
         // Create an adhoc task.
         $task = new adhoc_test_task();
         manager::queue_adhoc_task($task);
-        $now = time();
+        $now = $clock->time();
         // Get it from the scheduler, execute it, and mark it as failed.
         // The task will not be returned immediately.
         $this->assertNull(manager::get_next_adhoc_task($now));
+        // Should get the adhoc task (retry after delay). Fail it again.
-        // Should get the adhoc task (retry after delay). Fail it again.
+        $clock->bump(120);
-        $task = manager::get_next_adhoc_task($now + 120);
+        $task = manager::get_next_adhoc_task($clock->time());
         $this->assertInstanceOf('\\core\\task\\adhoc_test_task', $task);
         $this->assertEquals($taskid, $task->get_id());
      * @covers \core\task\adhoc_task
      */
     public function test_get_next_adhoc_task_maximum_fail_delay(): void {
         $this->resetAfterTest(true);
+        $clock = $this->mock_clock_with_frozen();
-        $now = time();
+        $now = $clock->time();
         // Create an adhoc task.
         $task = new adhoc_test_task();
      */
     public function test_adhoc_task_with_retry_flag(): void {
         global $DB;
         $this->resetAfterTest();
+        $clock = $this->mock_clock_with_frozen();
-        $now = time();
+        $now = $clock->time();
         // Create a normal adhoc task.
         $task = new adhoc_test_task();
         $taskid1 = manager::queue_adhoc_task(task: $task);
             conditions: ['id' => $taskid1]
         );
         $this->assertEquals(expected: 12 - 1, actual: $attemptsavailable);
         // Create a no-retry adhoc task.
-        $now = time();
+        $now = $clock->time();
         $task = new no_retry_adhoc_task();
         $taskid2 = manager::queue_adhoc_task(task: $task);
      */
     public function test_adhoc_task_clean_up(): void {
         global $DB, $CFG;
         $this->resetAfterTest();
+        $clock = $this->mock_clock_with_frozen();
         // Create two no-retry adhoc tasks.
         $task1 = new no_retry_adhoc_task();
         $taskid1 = manager::queue_adhoc_task(task: $task1);
         $task2 = new no_retry_adhoc_task();
         // Update the time of the task2 to be older more than 2 days.
         $DB->set_field(
             table: 'task_adhoc',
             newfield: 'firststartingtime',
-            newvalue: time() - (DAYSECS * 2) - 10, // Plus 10 seconds to make sure it is older than 2 days.
+            newvalue: $clock->time() - (DAYSECS * 2) - 10, // Plus 10 seconds to make sure it is older than 2 days.
             conditions: ['id' => $taskid2],
         );
         // Update the time of the task1 to be older than the cleanup time.
         $DB->set_field(
             table: 'task_adhoc',
             newfield: 'firststartingtime',
             // Plus 10 seconds to make sure it is older than the retention time.
-            newvalue: time() - $CFG->task_adhoc_failed_retention - 10,
+            newvalue: $clock->time() - $CFG->task_adhoc_failed_retention - 10,
             conditions: ['id' => $taskid1],
         );
         // Clean up failed adhoc tasks. task1 should be cleaned now.
      */
     public function test_adhoc_task_failed_will_retain_time_info(): void {
         global $DB;
         $this->resetAfterTest();
+        $clock = $this->mock_clock_with_frozen();
+        $now = $clock->time();
         $now = time();
         // Create an adhoc task.
         $task = new adhoc_test_task();
         // Queue it.
         $taskid = manager::queue_adhoc_task(task: $task);
         // Update the timecreated of the task to be older.
         $DB->set_field(
             table: 'task_adhoc',
             newfield: 'timecreated',
-            newvalue: time() - DAYSECS,
+            newvalue: $clock->time() - DAYSECS,
             conditions: ['id' => $taskid],
         );
      * Test future adhoc task execution.
      */
     public function test_get_next_adhoc_task_future(): void {
         $this->resetAfterTest(true);
+        $clock = $this->mock_clock_with_frozen();
+        $now = $clock->time();
         $now = time();
         // Create an adhoc task in future.
         $task = new adhoc_test_task();
         $task->set_next_run_time($now + 1000);
         $this->resetAfterTest();
         $task = new \mod_fake\task\adhoc_component_task();
+        manager::queue_adhoc_task($task);
+        $this->assertdebuggingcalledcount(
+,
-        manager::queue_adhoc_task($task);
+            array_fill(0, 2, 'Component not set and the class namespace does not match a valid component (mod_fake).'),
-        $this->assertDebuggingCalled('Component not set and the class namespace does not match a valid component (mod_fake).');
+        );
+    }
      * specified.
      */
     public function test_reschedule_or_queue_adhoc_task_match_no_change(): void {
         $this->resetAfterTest(true);
+        $clock = $this->mock_clock_with_frozen();
         // Schedule adhoc task.
         $task = new adhoc_test_task();
         $task->set_custom_data(['courseid' => 10]);
-        $task->set_next_run_time(time() + DAYSECS);
+        $task->set_next_run_time($clock->time() + DAYSECS);
         manager::reschedule_or_queue_adhoc_task($task);
     /**
      * Ensure that the reschedule_or_queue_adhoc_task function will update the run time if there are planned changes.
      */
     public function test_reschedule_or_queue_adhoc_task_match_update_runtime(): void {
         $this->resetAfterTest(true);
+        $clock = $this->mock_clock_with_frozen();
-        $initialruntime = time() + DAYSECS;
+        $initialruntime = $clock->time() + DAYSECS;
-        $newruntime = time() + WEEKSECS;
+        $newruntime = $clock->time() + WEEKSECS;
         // Schedule adhoc task.
         $task = new adhoc_test_task();
         $task->set_custom_data(['courseid' => 10]);
      * @covers \core\task\adhoc_task
      */
     public function test_adhoc_task_user_empty(): void {
         $this->resetAfterTest(true);
+        $clock = $this->mock_clock_with_frozen();
         // Create an adhoc task in future.
         $task = new adhoc_test_task();
         manager::queue_adhoc_task($task);
         // Get it back from the scheduler.
-        $now = time();
+        $now = $clock->time();
         $task = manager::get_next_adhoc_task($now);
         manager::adhoc_task_complete($task);
         $user = \core_user::get_user_by_username('admin');
         $task->set_userid($user->id);
         manager::queue_adhoc_task($task);
+        // Get it back from the scheduler.
-        // Get it back from the scheduler.
+        $clock = $this->mock_clock_with_frozen();
-        $now = time();
+        $now = $clock->time();
         $task = manager::get_next_adhoc_task($now);
         manager::adhoc_task_complete($task);
      */
     public function test_adhoc_task_get_first_starting_time(): void {
         global $DB;
         $this->resetAfterTest(true);
+        $clock = $this->mock_clock_with_frozen();
-        $now = time();
+        $now = $clock->time();
         // Create an adhoc task.
         $task = new adhoc_test_task();
             conditions: ['id' => $taskid],
         );
         $this->assertNull($firststartingtime);
         // This will make sure that the task will be started after the $now value.
-        sleep(3);
+        $clock->bump(5);
         // Get the task from the scheduler.
         $task = manager::get_next_adhoc_task(timestart: $now);
             conditions: ['id' => $taskid],
         );
         $this->assertNotNull($origintimestarted);
         $this->assertGreaterThan($now, $origintimestarted);
+        // Time travel 24 hours into the future.
+        $clock->bump(DAYSECS * 3);
         $now = $clock->time();
         // Get the task from the scheduler.
-        $task = manager::get_next_adhoc_task(timestart: $now + 86400);
+        $task = manager::get_next_adhoc_task(timestart: $now);
         // Mark the task as starting.
         manager::adhoc_task_starting($task);
         // Execute the task.
         $task->execute();
      * Test adhoc task sorting.
      */
     public function test_get_next_adhoc_task_sorting(): void {
         $this->resetAfterTest(true);
+        $clock = $this->mock_clock_with_frozen();
         // Create adhoc tasks.
         $task1 = new adhoc_test_task();
         $task1->set_next_run_time(1510000000);
         $task1->set_custom_data_as_string('Task 1');
         $task2->set_next_run_time(1530000000);
         manager::reschedule_or_queue_adhoc_task($task2);
         // Confirm, that tasks are sorted by nextruntime and then by id (ascending).
-        $task = manager::get_next_adhoc_task(time());
+        $task = manager::get_next_adhoc_task($clock->time());
         $this->assertEquals('Task 2', $task->get_custom_data_as_string());
         manager::adhoc_task_complete($task);
-        $task = manager::get_next_adhoc_task(time());
+        $task = manager::get_next_adhoc_task($clock->time());
         $this->assertEquals('Task 3', $task->get_custom_data_as_string());
         manager::adhoc_task_complete($task);
-        $task = manager::get_next_adhoc_task(time());
+        $task = manager::get_next_adhoc_task($clock->time());
+    }
     /**
      * Test send messages when adhoc task reaches the max fail delay time.
-     *
-     * @covers ::adhoc_task_failed
+     *
-     * @covers ::send_failed_task_max_delay_message
+     * @covers \core\task\failed_task_callbacks::send_failed_task_max_delay_message
      */
     public function test_adhoc_message_max_fail_delay(): void {
         $this->resetAfterTest();
+        $this->setAdminUser();
-        $this->setAdminUser();
+        $clock = $this->mock_clock_with_frozen();
         // Redirect messages.
         $messagesink = $this->redirectMessages();
         // Create an adhoc task.
         $task = new adhoc_test_task();
         manager::queue_adhoc_task($task);
-        $now = time();
+        $now = $clock->time();
         // Check first message information.
         $this->assertStringContainsString('Task failed: Test adhoc class', $messages[0]->subject);
         $this->assertEquals('failedtaskmaxdelay', $messages[0]->eventtype);
         $this->assertEquals('-10', $messages[0]->useridfrom);
         $this->assertEquals('2', $messages[0]->useridto);
+        $this->assertEquals('Task logs', $messages[0]->contexturlname);
+        $this->assertEquals(
+            (new url('/admin/tasklogs.php', ['filter' => get_class($task)]))->out(false),
+            $messages[0]->contexturl,
+        );
         // Close sink.
         $messagesink->close();
+    }

Proyectos de Subversion Moodle

(root)/lib/tests/task/adhoc_task_test.php – Rev 1 → 1441