<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// 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;

/**
 * Test class for adhoc tasks.
 *
 * @package core
 * @category test
 * @copyright 2013 Damyon Wiese
 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 * @covers \core\task\manager
 */
final class adhoc_task_test extends \advanced_testcase {
    public static function setUpBeforeClass(): void {
        parent::setUpBeforeClass();

        require_once(__DIR__ . '/../fixtures/task_fixtures.php');
    }

    /**
     * Test getting name of task that implements it's own get_name method
     *
     * @covers \core\task\adhoc_task
     */
    public function test_get_name(): void {
        $task = new \core\task\adhoc_test_task();
        $this->assertEquals('Test adhoc class', $task->get_name());
    }

    /**
     * Test getting name of task that uses the default implementation of get_name
     *
     * @covers \core\task\adhoc_task
     */
    public function test_get_name_default(): void {
        $task = new \mod_fake\task\adhoc_component_task();
        $this->assertEquals('Adhoc component task', $task->get_name());
    }

    /**
     * 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);

        // Get it from the scheduler.
        $task = manager::get_next_adhoc_task($clock->time());
        $this->assertInstanceOf('\\core\\task\\adhoc_test_task', $task);
        $task->execute();
        manager::adhoc_task_complete($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);

        $classname = get_class($task);

        // The task will not be returned.
        $this->assertNull(manager::get_next_adhoc_task($clock->time(), true, "{$classname}notexists"));

        // Get it from the scheduler.
        $task = manager::get_next_adhoc_task($clock->time(), true, $classname);
        $this->assertInstanceOf('\\core\\task\\adhoc_test_task', $task);
        $task->execute();
        manager::adhoc_task_complete($task);
    }

    /**
     * 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 = $clock->time();

        // Get it from the scheduler, execute it, and mark it as failed.
        $task = manager::get_next_adhoc_task($now);
        $taskid = $task->get_id();
        $task->execute();
        manager::adhoc_task_failed($task);

        // 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.
        $clock->bump(120);
        $task = manager::get_next_adhoc_task($clock->time());
        $this->assertInstanceOf('\\core\\task\\adhoc_test_task', $task);
        $this->assertEquals($taskid, $task->get_id());
        $task->execute();
        manager::adhoc_task_failed($task);

        // Should get the adhoc task immediately.
        $task = manager::get_adhoc_task($taskid);
        $this->assertInstanceOf('\\core\\task\\adhoc_test_task', $task);
        $this->assertEquals($taskid, $task->get_id());
        $task->execute();
        manager::adhoc_task_complete($task);

        // Should not get any task.
        $this->assertNull(manager::get_next_adhoc_task($now));
    }

    /**
     * Test that failed tasks eventually hit the maximum delay.
     *
     * @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 = $clock->time();

        // Create an adhoc task.
        $task = new adhoc_test_task();
        $attemptsavailable = $task->get_attempts_available();
        manager::queue_adhoc_task($task);

        // Exhaust all attempts available.
        for ($x = 0; $x < $attemptsavailable; $x++) {
            $delay = $task->get_fail_delay() * 2;
            $task = manager::get_next_adhoc_task($now + $delay);
            $task->execute();
            manager::adhoc_task_failed($task);
        }
        // Check that the fail delay is now set to 24 hours (the maximum amount of times).
        $this->assertEquals(DAYSECS, $task->get_fail_delay());
    }

    /**
     * Test adhoc task failure retry backoff.
     */
    public function test_adhoc_task_with_retry_flag(): void {
        global $DB;
        $this->resetAfterTest();

        $clock = $this->mock_clock_with_frozen();

        $now = $clock->time();
        // Create a normal adhoc task.
        $task = new adhoc_test_task();
        $taskid1 = manager::queue_adhoc_task(task: $task);

        // This is a normal task, so it should have limited attempts.
        $attemptsavailable = $DB->get_field(
            table: 'task_adhoc',
            return: 'attemptsavailable',
            conditions: ['id' => $taskid1]
        );
        $this->assertEquals(expected: 12, actual: $attemptsavailable);

        // Get the task from the scheduler, execute it, and mark it as failed.
        $task = manager::get_next_adhoc_task(timestart: $now);
        $taskid1 = $task->get_id();
        $task->execute();
        manager::adhoc_task_failed(task: $task);

        // Now that the task has failed, there should be one less attempt available.
        $attemptsavailable = $DB->get_field(
            table: 'task_adhoc',
            return: 'attemptsavailable',
            conditions: ['id' => $taskid1]
        );
        $this->assertEquals(expected: 12 - 1, actual: $attemptsavailable);

        // Create a no-retry adhoc task.
        $now = $clock->time();
        $task = new no_retry_adhoc_task();
        $taskid2 = manager::queue_adhoc_task(task: $task);

        // This is no-retry task, so it should have only 1 attempt available.
        $attemptsavailable = $DB->get_field(
            table: 'task_adhoc',
            return: 'attemptsavailable',
            conditions: ['id' => $taskid2]
        );
        $this->assertEquals(
            expected: 1,
            actual: $attemptsavailable,
        );

        // Get the task from the scheduler, execute it, and mark it as failed.
        $task = manager::get_next_adhoc_task(timestart: $now);
        $taskid2 = $task->get_id();
        $task->execute();
        manager::adhoc_task_failed(task: $task);

        // This is no-retry task, the remaining available attempts should be reduced to 0.
        $attemptsavailable = $DB->get_field(
            table: 'task_adhoc',
            return: 'attemptsavailable',
            conditions: ['id' => $taskid2]
        );
        $this->assertEquals(
            expected: 0,
            actual: $attemptsavailable,
        );

        // There will be two records in the task_adhoc table, one for each task.
        $this->assertEquals(
            expected: 2,
            actual: $DB->count_records(table: 'task_adhoc')
        );
        // But get_next_adhoc_task() should return only the allowed re-try task.
        // The no-retry task should not be returned because it has no remaining attempts.
        do {
            $task = manager::get_next_adhoc_task(timestart: $now + 86400);
            if ($task) {
                manager::adhoc_task_failed(task: $task);
                $this->assertEquals(
                    expected: $taskid1,
                    actual: $task->get_id(),
                );
            }
        } while ($task);

        // Mark the normal task as complete.
        $task = manager::get_adhoc_task(taskid: $taskid1);
        manager::adhoc_task_complete($task);

        // There will be one record in the task_adhoc table.
        $this->assertEquals(
            expected: 1,
            actual: $DB->count_records(table: 'task_adhoc')
        );

        // But get_next_adhoc_task() should return nothing.
        $this->assertNull(manager::get_next_adhoc_task(timestart: $now + 86400));
    }

    /**
     * Test adhoc task failure cleanup.
     */
    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();
        $taskid2 = manager::queue_adhoc_task(task: $task2);

        // Get the tasks and mark it as failed.
        $task = manager::get_adhoc_task($taskid1);
        manager::adhoc_task_failed(task: $task);
        $task = manager::get_adhoc_task($taskid2);
        manager::adhoc_task_failed(task: $task);

        // These are no-retry tasks, the remaining available attempts should be reduced to 0.
        $this->assertEquals(
            expected: 0,
            actual: $DB->get_field(
                table: 'task_adhoc',
                return: 'attemptsavailable',
                conditions: ['id' => $taskid1],
            ),
        );
        $this->assertEquals(
            expected: 0,
            actual: $DB->get_field(
                table: 'task_adhoc',
                return: 'attemptsavailable',
                conditions: ['id' => $taskid2],
            ),
        );

        // There will be two records in the task_adhoc table.
        $this->assertEquals(
            expected: 2,
            actual: $DB->count_records(table: 'task_adhoc'),
        );

        // Clean up failed adhoc tasks. This will clean nothing because the tasks are not old enough.
        manager::clean_failed_adhoc_tasks();

        // There will be two records in the task_adhoc table.
        $this->assertEquals(
            expected: 2,
            actual: $DB->count_records(table: 'task_adhoc'),
        );

        // Update the time of the task2 to be older more than 2 days.
        $DB->set_field(
            table: 'task_adhoc',
            newfield: 'firststartingtime',
            newvalue: $clock->time() - (DAYSECS * 2) - 10, // Plus 10 seconds to make sure it is older than 2 days.
            conditions: ['id' => $taskid2],
        );

        // Clean up failed adhoc tasks. This will clean nothing because the tasks are not old enough.
        manager::clean_failed_adhoc_tasks();

        // There will be two records in the task_adhoc table.
        $this->assertEquals(
            expected: 2,
            actual: $DB->count_records(table: 'task_adhoc'),
        );

        // 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: $clock->time() - $CFG->task_adhoc_failed_retention - 10,
            conditions: ['id' => $taskid1],
        );

        // Clean up failed adhoc tasks. task1 should be cleaned now.
        manager::clean_failed_adhoc_tasks();

        // There will be one record in the task_adhoc table.
        $this->assertEquals(
            expected: 1,
            actual: $DB->count_records(table: 'task_adhoc'),
        );

        // Update the duration of the Failed ad hoc task retention period to one day.
        $CFG->task_adhoc_failed_retention = DAYSECS;

        // Clean up failed adhoc tasks. task2 should be cleaned now.
        manager::clean_failed_adhoc_tasks();

        // The task_adhoc table should be empty now.
        $this->assertEquals(
            expected: 0,
            actual: $DB->count_records(table: 'task_adhoc'),
        );
    }

    /**
     * Test adhoc task failure will retain the time information.
     */
    public function test_adhoc_task_failed_will_retain_time_info(): void {
        global $DB;
        $this->resetAfterTest();

        $clock = $this->mock_clock_with_frozen();
        $now = $clock->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: $clock->time() - DAYSECS,
            conditions: ['id' => $taskid],
        );

        // Get the timecreated value before marking the task as failed.
        $timecreatedbefore = $DB->get_field(
            table: 'task_adhoc',
            return: 'timecreated',
            conditions: ['id' => $taskid],
        );

        // Get the task from the scheduler.
        $task = manager::get_next_adhoc_task(timestart: $now);
        // Execute the task.
        $task->execute();
        // Mark the task as failed.
        manager::adhoc_task_failed(task: $task);

        // Get the timecreated value after marking the task as failed.
        $timecreatedafter = $DB->get_field(
            table: 'task_adhoc',
            return: 'timecreated',
            conditions: ['id' => $taskid],
        );

        // The timecreated values should be the same.
        $this->assertEquals($timecreatedbefore, $timecreatedafter);
    }

    /**
     * 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();

        // Create an adhoc task in future.
        $task = new adhoc_test_task();
        $task->set_next_run_time($now + 1000);
        manager::queue_adhoc_task($task);

        // Fetching the next task should not return anything.
        $this->assertNull(manager::get_next_adhoc_task($now));

        // Fetching in the future should return the task.
        $task = manager::get_next_adhoc_task($now + 1020);
        $this->assertInstanceOf('\\core\\task\\adhoc_test_task', $task);
        $task->execute();
        manager::adhoc_task_complete($task);
    }

    /**
     * Test queueing an adhoc task belonging to a component, where we set the task component accordingly
     */
    public function test_queue_adhoc_task_for_component(): void {
        $this->resetAfterTest();

        $task = new \mod_forum\task\send_user_digests();
        $task->set_component('mod_test');

        manager::queue_adhoc_task($task);
        $this->assertDebuggingNotCalled();
    }

    /**
     * Test queueing an adhoc task belonging to a component, where we do not set the task component
     */
    public function test_queue_task_for_component_without_set_component(): void {
        $this->resetAfterTest();

        $task = new \mod_forum\task\send_user_digests();

        manager::queue_adhoc_task($task);
        $this->assertDebuggingNotCalled();

        // Assert the missing component was set.
        $this->assertEquals('mod_forum', $task->get_component());
    }

    /**
     * Test queueing an adhoc task belonging to an invalid component, where we do not set the task component
     */
    public function test_queue_task_for_invalid_component_without_set_component(): void {
        $this->resetAfterTest();

        $task = new \mod_fake\task\adhoc_component_task();

        manager::queue_adhoc_task($task);
        $this->assertDebuggingCalled('Component not set and the class namespace does not match a valid component (mod_fake).');
    }

    /**
     * Test empty set of adhoc tasks
     */
    public function test_get_adhoc_tasks_empty_set(): void {
        $this->resetAfterTest(true);

        $this->assertEquals([], manager::get_adhoc_tasks('\\core\\task\\adhoc_test_task'));
    }

    /**
     * Test correct set of adhoc tasks is returned for class.
     */
    public function test_get_adhoc_tasks_result_set(): void {
        $this->resetAfterTest(true);

        for ($i = 0; $i < 3; $i++) {
            $task = new adhoc_test_task();
            manager::queue_adhoc_task($task);
        }

        for ($i = 0; $i < 3; $i++) {
            $task = new adhoc_test2_task();
            manager::queue_adhoc_task($task);
        }

        $adhoctests = manager::get_adhoc_tasks('\\core\\task\\adhoc_test_task');
        $adhoctest2s = manager::get_adhoc_tasks('\\core\\task\\adhoc_test2_task');

        $this->assertCount(3, $adhoctests);
        $this->assertCount(3, $adhoctest2s);

        foreach ($adhoctests as $task) {
            $this->assertInstanceOf('\\core\\task\\adhoc_test_task', $task);
        }

        foreach ($adhoctest2s as $task) {
            $this->assertInstanceOf('\\core\\task\\adhoc_test2_task', $task);
        }
    }

    /**
     * Ensure that the reschedule_or_queue_adhoc_task function will schedule a new task if no tasks exist.
     */
    public function test_reschedule_or_queue_adhoc_task_no_existing(): void {
        $this->resetAfterTest(true);

        // Schedule adhoc task.
        $task = new adhoc_test_task();
        $task->set_custom_data(['courseid' => 10]);
        manager::reschedule_or_queue_adhoc_task($task);
        $this->assertEquals(1, count(manager::get_adhoc_tasks('core\task\adhoc_test_task')));
    }

    /**
     * Ensure that the reschedule_or_queue_adhoc_task function will schedule a new task if a task for the same user does
     * not exist.
     */
    public function test_reschedule_or_queue_adhoc_task_different_user(): void {
        $this->resetAfterTest(true);
        $user = \core_user::get_user_by_username('admin');

        // Schedule adhoc task.
        $task = new adhoc_test_task();
        $task->set_custom_data(['courseid' => 10]);
        manager::reschedule_or_queue_adhoc_task($task);

        // Schedule adhoc task for a different user.
        $task = new adhoc_test_task();
        $task->set_custom_data(['courseid' => 10]);
        $task->set_userid($user->id);
        manager::reschedule_or_queue_adhoc_task($task);

        $this->assertEquals(2, count(manager::get_adhoc_tasks('core\task\adhoc_test_task')));
    }

    /**
     * Ensure that the reschedule_or_queue_adhoc_task function will schedule a new task if a task with different custom
     * data exists.
     */
    public function test_reschedule_or_queue_adhoc_task_different_data(): void {
        $this->resetAfterTest(true);

        // Schedule adhoc task.
        $task = new adhoc_test_task();
        $task->set_custom_data(['courseid' => 10]);
        manager::reschedule_or_queue_adhoc_task($task);

        // Schedule adhoc task for a different user.
        $task = new adhoc_test_task();
        $task->set_custom_data(['courseid' => 11]);
        manager::reschedule_or_queue_adhoc_task($task);

        $this->assertEquals(2, count(manager::get_adhoc_tasks('core\task\adhoc_test_task')));
    }

    /**
     * Ensure that the reschedule_or_queue_adhoc_task function will not make any change for matching data if no time was
     * 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($clock->time() + DAYSECS);
        manager::reschedule_or_queue_adhoc_task($task);

        $before = manager::get_adhoc_tasks('core\task\adhoc_test_task');

        // Schedule the task again but do not specify a time.
        $task = new adhoc_test_task();
        $task->set_custom_data(['courseid' => 10]);
        manager::reschedule_or_queue_adhoc_task($task);

        $this->assertEquals(1, count(manager::get_adhoc_tasks('core\task\adhoc_test_task')));
        $this->assertEquals($before, manager::get_adhoc_tasks('core\task\adhoc_test_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 = $clock->time() + DAYSECS;
        $newruntime = $clock->time() + WEEKSECS;

        // Schedule adhoc task.
        $task = new adhoc_test_task();
        $task->set_custom_data(['courseid' => 10]);
        $task->set_next_run_time($initialruntime);
        manager::reschedule_or_queue_adhoc_task($task);

        $before = manager::get_adhoc_tasks('core\task\adhoc_test_task');

        // Schedule the task again.
        $task = new adhoc_test_task();
        $task->set_custom_data(['courseid' => 10]);
        $task->set_next_run_time($newruntime);
        manager::reschedule_or_queue_adhoc_task($task);

        $tasks = manager::get_adhoc_tasks('core\task\adhoc_test_task');
        $this->assertEquals(1, count($tasks));
        $this->assertNotEquals($before, $tasks);
        $firsttask = reset($tasks);
        $this->assertEquals($newruntime, $firsttask->get_next_run_time());
    }

    /**
     * Test queue_adhoc_task "if not scheduled".
     */
    public function test_queue_adhoc_task_if_not_scheduled(): void {
        $this->resetAfterTest(true);
        $user = \core_user::get_user_by_username('admin');

        // Schedule adhoc task.
        $task = new adhoc_test_task();
        $task->set_custom_data(['courseid' => 10]);
        $this->assertNotEmpty(manager::queue_adhoc_task($task, true));
        $this->assertEquals(1, count(manager::get_adhoc_tasks('core\task\adhoc_test_task')));

        // Schedule adhoc task with a user.
        $task = new adhoc_test_task();
        $task->set_custom_data(['courseid' => 10]);
        $task->set_userid($user->id);
        $this->assertNotEmpty(manager::queue_adhoc_task($task, true));
        $this->assertEquals(2, count(manager::get_adhoc_tasks('core\task\adhoc_test_task')));

        // Schedule same adhoc task with different custom data.
        $task = new adhoc_test_task();
        $task->set_custom_data(['courseid' => 1]);
        $this->assertNotEmpty(manager::queue_adhoc_task($task, true));
        $this->assertEquals(3, count(manager::get_adhoc_tasks('core\task\adhoc_test_task')));

        // Schedule same adhoc task with same custom data.
        $task = new adhoc_test_task();
        $task->set_custom_data(['courseid' => 1]);
        $this->assertEmpty(manager::queue_adhoc_task($task, true));
        $this->assertEquals(3, count(manager::get_adhoc_tasks('core\task\adhoc_test_task')));

        // Schedule same adhoc task with same custom data and a user.
        $task = new adhoc_test_task();
        $task->set_custom_data(['courseid' => 1]);
        $task->set_userid($user->id);
        $this->assertNotEmpty(manager::queue_adhoc_task($task, true));
        $this->assertEquals(4, count(manager::get_adhoc_tasks('core\task\adhoc_test_task')));

        // Schedule same adhoc task without custom data.
        // Note: This task was created earlier.
        $task = new adhoc_test_task();
        $this->assertNotEmpty(manager::queue_adhoc_task($task, true));
        $this->assertEquals(5, count(manager::get_adhoc_tasks('core\task\adhoc_test_task')));

        // Schedule same adhoc task without custom data (again).
        $task5 = new adhoc_test_task();
        $this->assertEmpty(manager::queue_adhoc_task($task5, true));
        $this->assertEquals(5, count(manager::get_adhoc_tasks('core\task\adhoc_test_task')));

        // Schedule same adhoc task without custom data but with a userid.
        $task6 = new adhoc_test_task();
        $user = \core_user::get_user_by_username('admin');
        $task6->set_userid($user->id);
        $this->assertNotEmpty(manager::queue_adhoc_task($task6, true));
        $this->assertEquals(6, count(manager::get_adhoc_tasks('core\task\adhoc_test_task')));

        // Schedule same adhoc task again without custom data but with a userid.
        $task6 = new adhoc_test_task();
        $user = \core_user::get_user_by_username('admin');
        $task6->set_userid($user->id);
        $this->assertEmpty(manager::queue_adhoc_task($task6, true));
        $this->assertEquals(6, count(manager::get_adhoc_tasks('core\task\adhoc_test_task')));
    }

    /**
     * Test that when no userid is specified, it returns empty from the DB
     * too.
     * @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 = $clock->time();
        $task = manager::get_next_adhoc_task($now);
        manager::adhoc_task_complete($task);

        $this->assertEmpty($task->get_userid());
    }

    /**
     * Test that when a userid is specified, that userid is subsequently
     * returned.
     *
     * @covers \core\task\adhoc_task
     */
    public function test_adhoc_task_user_set(): void {
        $this->resetAfterTest(true);

        // Create an adhoc task in future.
        $task = new adhoc_test_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.
        $clock = $this->mock_clock_with_frozen();
        $now = $clock->time();
        $task = manager::get_next_adhoc_task($now);
        manager::adhoc_task_complete($task);

        $this->assertEquals($user->id, $task->get_userid());
    }

    /**
     * Test adhoc task with the first starting time.
     */
    public function test_adhoc_task_get_first_starting_time(): void {
        global $DB;
        $this->resetAfterTest(true);

        $clock = $this->mock_clock_with_frozen();
        $now = $clock->time();

        // Create an adhoc task.
        $task = new adhoc_test_task();
        // Queue it.
        $taskid = manager::queue_adhoc_task(task: $task);

        // Get the firststartingtime value.
        $firststartingtime = $DB->get_field(
            table: 'task_adhoc',
            return: 'firststartingtime',
            conditions: ['id' => $taskid],
        );
        $this->assertNull($firststartingtime);

        // This will make sure that the task will be started after the $now value.
        $clock->bump(5);

        // Get the task from the scheduler.
        $task = manager::get_next_adhoc_task(timestart: $now);
        // Mark the task as starting.
        manager::adhoc_task_starting($task);
        // Execute the task.
        $task->execute();
        // Mark the task as failed.
        manager::adhoc_task_failed(task: $task);

        // Get the firststartingtime value.
        $origintimestarted = $DB->get_field(
            table: 'task_adhoc',
            return: 'firststartingtime',
            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);
        // Mark the task as starting.
        manager::adhoc_task_starting($task);
        // Execute the task.
        $task->execute();
        // Mark the task as failed.
        manager::adhoc_task_failed(task: $task);

        // Get the firststartingtime value.
        $firststartingtime = $DB->get_field(
            table: 'task_adhoc',
            return: 'firststartingtime',
            conditions: ['id' => $taskid],
        );

        // The firststartingtime value should not be changed.
        $this->assertEquals($origintimestarted, $firststartingtime);
    }

    /**
     * Test get_concurrency_limit() method to return 0 by default.
     *
     * @covers \core\task\adhoc_task
     */
    public function test_get_concurrency_limit(): void {
        $this->resetAfterTest(true);
        $task = new adhoc_test_task();
        $concurrencylimit = $task->get_concurrency_limit();
        $this->assertEquals(0, $concurrencylimit);
    }

    /**
     * Test get_concurrency_limit() method to return a default value set in config.
     * @covers \core\task\adhoc_task
     */
    public function test_get_concurrency_limit_default(): void {
        $this->resetAfterTest(true);
        set_config('task_concurrency_limit_default', 10);
        $task = new adhoc_test_task();
        $concurrencylimit = $task->get_concurrency_limit();
        $this->assertEquals(10, $concurrencylimit);
    }

    /**
     * Test get_concurrency_limit() method to return a value for specific task class.
     * @covers \core\task\adhoc_task
     */
    public function test_get_concurrency_limit_for_task(): void {
        global $CFG;
        $this->resetAfterTest(true);
        set_config('task_concurrency_limit_default', 10);
        $CFG->task_concurrency_limit = ['core\task\adhoc_test_task' => 5];
        $task = new adhoc_test_task();
        $concurrencylimit = $task->get_concurrency_limit();
        $this->assertEquals(5, $concurrencylimit);
    }

    /**
     * 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');
        manager::queue_adhoc_task($task1);

        $task2 = new adhoc_test_task();
        $task2->set_next_run_time(1520000000);
        $task2->set_custom_data_as_string('Task 2');
        manager::queue_adhoc_task($task2);

        $task3 = new adhoc_test_task();
        $task3->set_next_run_time(1520000000);
        $task3->set_custom_data_as_string('Task 3');
        manager::queue_adhoc_task($task3);

        // Shuffle tasks.
        $task1->set_next_run_time(1540000000);
        manager::reschedule_or_queue_adhoc_task($task1);

        $task3->set_next_run_time(1530000000);
        manager::reschedule_or_queue_adhoc_task($task3);

        $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($clock->time());
        $this->assertEquals('Task 2', $task->get_custom_data_as_string());
        manager::adhoc_task_complete($task);

        $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($clock->time());
        $this->assertEquals('Task 1', $task->get_custom_data_as_string());
        manager::adhoc_task_complete($task);
    }

    /**
     * Test adhoc task run from CLI.
     */
    public function test_run_adhoc_from_cli(): void {
        $this->resetAfterTest(true);

        $taskid = 1;

        if (!manager::is_runnable()) {
            $this->markTestSkipped("Cannot run tasks");
        }

        ob_start();
        manager::run_adhoc_from_cli($taskid);
        $output = ob_get_contents();
        ob_end_clean();

        $this->assertMatchesRegularExpression(
            sprintf('!admin/cli/adhoc_task.php\W+--id=%d\W+--force!', $taskid),
            $output
        );
    }

    /**
     * Test adhoc class run from CLI.
     */
    public function test_run_all_adhoc_from_cli(): void {
        $this->resetAfterTest(true);

        $classname = 'fake';

        if (!manager::is_runnable()) {
            $this->markTestSkipped("Cannot run tasks");
        }

        ob_start();
        manager::run_all_adhoc_from_cli(false, $classname);
        $output = ob_get_contents();
        ob_end_clean();

        $this->assertMatchesRegularExpression(
            sprintf('!admin/cli/adhoc_task.php\W+--classname=%s\W+--force!', $classname),
            $output
        );
    }

    /**
     * Test send messages when adhoc task reaches the max fail delay time.
     *
     * @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();

        $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 = $clock->time();

        // Get it from the scheduler, execute it, and mark it as failed.
        $task = manager::get_next_adhoc_task($now);
        $taskid = $task->get_id();
        $task->execute();

        // Catch the message. The task has not reach the max time delay yet.
        manager::adhoc_task_failed($task);
        $messages = $messagesink->get_messages();
        $this->assertCount(0, $messages);

        // Should get the adhoc task immediately.
        $task = manager::get_adhoc_task($taskid);
        $task->set_fail_delay(86400);
        $this->assertInstanceOf('\\core\\task\\adhoc_test_task', $task);
        $this->assertEquals($taskid, $task->get_id());
        $task->execute();

        // Catch the message.
        manager::adhoc_task_failed($task);
        $messages = $messagesink->get_messages();
        $this->assertCount(1, $messages);

        // Get the task and execute it second time.
        $task = manager::get_adhoc_task($taskid);
        // Set the fail delay to 12 hours.
        $task->set_fail_delay(43200);
        $task->execute();
        manager::adhoc_task_failed($task);

        // Catch the message.
        $messages = $messagesink->get_messages();
        $this->assertCount(2, $messages);

        // Get the task and execute it third time.
        $task = manager::get_adhoc_task($taskid);
        // Set the fail delay to 48 hours.
        $task->set_fail_delay(172800);
        $task->execute();
        manager::adhoc_task_failed($task);

        // Catch the message.
        $messages = $messagesink->get_messages();
        $this->assertCount(3, $messages);

        // 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);

        // Close sink.
        $messagesink->close();
    }
}
