Proyectos de Subversion Moodle

<?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/>.

/**
 * Unit tests for the relativedate condition.
 *
 * @package   availability_relativedate
 * @copyright 2022 eWallah.net
 * @author    Renaat Debleu <info@eWallah.net>
 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
namespace availability_relativedate;

use availability_relativedate\condition;
use context_module;
use core\event\course_module_completion_updated;
use core_availability\{tree, mock_info, info_module};
use stdClass;

/**
 * Unit tests for the relativedate condition.
 *
 * @package   availability_relativedate
 * @copyright 2022 eWallah.net
 * @author    Renaat Debleu <info@eWallah.net>
 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 * @coversDefaultClass \availability_relativedate\condition
 */
final class condition_test extends \advanced_testcase {
    /** @var stdClass course. */
    private $course;

    /** @var stdClass user. */
    private $user;

    /**
     * Create course and page.
     */
    public function setUp(): void {
        global $CFG;
        require_once($CFG->dirroot . '/availability/tests/fixtures/mock_info.php');
        require_once($CFG->dirroot . '/availability/tests/fixtures/mock_info_module.php');
        require_once($CFG->libdir . '/completionlib.php');
        $this->resetAfterTest();
        $this->setAdminUser();
        $CFG->enablecompletion = true;
        $CFG->enableavailability = true;
        set_config('enableavailability', true);
        $dg = $this->getDataGenerator();
        $now = time();
        $this->course = $dg->create_course(['startdate' => $now, 'enddate' => $now + 7 * WEEKSECS, 'enablecompletion' => 1]);
        $this->user = $dg->create_user(['timezone' => 'UTC']);
        $dg->enrol_user($this->user->id, $this->course->id, 5, time());
    }

    /**
     * Relative dates tree provider.
     */
    public static function tree_provider(): array {
        return [
            'After start course' => [2, 1, 1, "+2 hour", "From"],
            'Before end course' => [3, 2, 2, '-3 day', 'Until'],
            'After end enrol' => [4, 3, 3, '+4 week', 'From'],
            'After end method' => [4, 3, 4, '+4 week', 'From'],
            'After end course' => [3, 2, 5, '+3 day', 'From'],
            'Before start course' => [2, 1, 6, "-2 hour", "Until"],
        ];
    }

    /**
     * Test tree.
     *
     * @dataProvider tree_provider
     * @param int $n number to skip
     * @param int $d Minute - hour - day - week  - month
     * @param int $s relative to
     * @param string $str
     * @param string $result
     * @covers \availability_relativedate\condition
     */
    public function test_tree($n, $d, $s, $str, $result): void {
        $arr = (object)['type' => 'relativedate', 'n' => $n, 'd' => $d, 's' => $s, 'm' => 9999999];
        $stru = (object)['op' => '|', 'show' => true, 'c' => [$arr]];
        $tree = new tree($stru);
        $this->assertFalse($tree->is_available_for_all());
        $this->setUser($this->user);
        $info = new mock_info($this->course, $this->user->id);
        $strf = get_string('strftimedatetime', 'langconfig');
        $nau = 'Not available unless:';
        $calc = userdate(strtotime($str, $this->get_reldate($s)), $strf, 0);
        $this->assertEquals("$nau $result $calc", $tree->get_full_information($info));
        $tree->check_available(false, $info, false, $this->user->id)->is_available();
    }

    /**
     * Tests relative module.
     * @covers \availability_relativedate\condition
     */
    public function test_relative_module(): void {
        $this->setTimezone('UTC');
        $dg = $this->getDataGenerator();
        $page = $dg->get_plugin_generator('mod_page')->create_instance(['course' => $this->course]);
        $stru = (object)['op' => '|', 'show' => true,
            'c' => [(object)['type' => 'relativedate', 'n' => 7, 'd' => 0, 's' => 7, 'm' => $page->cmid]],
        ];
        $tree = new tree($stru);
        $this->setUser($this->user);
        $info = new mock_info($this->course, $this->user->id);
        [$sql, $params] = $tree->get_user_list_sql(false, $info, false);
        $this->assertEquals('', $sql);
        $this->assertEquals([], $params);
        // 7 Minutes after completion of module.
        $this->assertStringContainsString('7 minutes after completion of activity', $tree->get_full_information($info));
        $this->do_cron();
        $this->assertFalse($tree->is_available_for_all());
    }

    /**
     * Relative dates description provider.
     */
    public static function description_provider(): array {
        return [
            'After start course' => [2, 1, 1, '+2 hour', 'From', 'Until', '2 hours after course start date'],
            'Before end course' => [3, 2, 2, '-3 day', 'Until', 'From', '3 days before course end date'],
            'After end enrol' => [4, 3, 3, '+4 week', 'From', 'Until', '4 weeks after user enrolment date'],
            'After end method' => [4, 3, 4, '+4 week', 'From', 'Until', '4 weeks after enrolment method end date'],
            'After end course' => [3, 2, 5, '+3 day', 'From', 'Until', '3 days after course end date'],
            'Before start course' => [2, 1, 6, '-2 hour', 'Until', 'From', '2 hours before course start date'],
        ];
    }

    /**
     * Test description.
     *
     * @dataProvider description_provider
     * @param int $n number to skip
     * @param int $d Minute - hour - day - week  - month
     * @param int $s relative to
     * @param string $str
     * @param string $result1
     * @param string $result2
     * @param string $result3
     * @covers \availability_relativedate\condition
     */
    public function test_description($n, $d, $s, $str, $result1, $result2, $result3): void {
        $strf = get_string('strftimedatetime', 'langconfig');
        $nau = 'Not available unless:';
        $info = new mock_info($this->course, $this->user->id);
        $this->setUser($this->user);
        $cond = new condition((object)['type' => 'relativedate', 'n' => $n, 'd' => $d, 's' => $s, 'm' => 99999]);
        $calc = userdate(strtotime($str, $this->get_reldate($s)), $strf);
        $this->assertEquals("$result1 $calc", $cond->get_description(true, false, $info));
        $this->assertEquals("$result2 $calc", $cond->get_description(true, true, $info));
        $this->assertEquals("$result1 $calc", $cond->get_description(false, false, $info));
        $this->assertEquals("$result2 $calc", $cond->get_description(false, true, $info));
        $this->assertEquals("$nau $result1 $calc", $cond->get_standalone_description(false, false, $info));
        $this->assertEquals("$nau $result2 $calc", $cond->get_standalone_description(false, true, $info));

        $this->setAdminUser();
        $this->assertStringContainsString($result3, $cond->get_description(true, false, $info));
        $this->assertNotEmpty($cond->get_standalone_description(false, false, $info));
    }

    /**
     * Tests the get_description and get_standalone_description functions.
     * @covers \availability_relativedate\condition
     */
    public function test_get_description(): void {
        global $DB;
        $this->get_reldate(4);
        $info = new mock_info($this->course, $this->user->id);
        $this->setUser($this->user);

        $pg = $this->getDataGenerator()->get_plugin_generator('mod_page');
        $page0 = $pg->create_instance(['course' => $this->course, 'completion' => COMPLETION_TRACKING_MANUAL]);
        $page1 = $pg->create_instance(['course' => $this->course, 'completion' => COMPLETION_TRACKING_MANUAL]);

        $str = '{"op":"|","show":true,"c":[{"type":"relativedate","n":4,"d":4,"s":7,"m":' . $page1->cmid . '}]}';
        $DB->set_field('course_modules', 'availability', $str, ['id' => $page0->cmid]);
        rebuild_course_cache($this->course->id, true);
        $cond = new condition((object)['type' => 'relativedate', 'n' => 4, 'd' => 4, 's' => 7, 'm' => $page1->cmid]);
        $this->assertStringContainsString("4 months after completion of activity", $cond->get_description(true, false, $info));
        $this->assertStringContainsString("4 months after completion of activity", $cond->get_description(true, true, $info));
        $this->assertStringContainsString("4 months after completion of activity", $cond->get_description(false, false, $info));
        $this->assertStringContainsString("4 months after completion of activity", $cond->get_description(false, true, $info));
        $this->assertFalse($cond->completion_value_used($this->course, $page0->cmid));
        $this->assertTrue($cond->completion_value_used($this->course, $page1->cmid));

        $modinfo = get_fast_modinfo($this->course);
        $str = '{"op":"|","show":true,"c":[{"type":"relativedate","n":4,"d":4,"s":7,"m":' . $page0->cmid . '}]}';
        foreach ($modinfo->get_section_info_all() as $section) {
            $DB->set_field('course_sections', 'availability', $str, ['id' => $section->id]);
        }
        $this->do_cron();
        $cond = new condition((object)['type' => 'relativedate', 'n' => 4, 'd' => 4, 's' => 7, 'm' => $page1->cmid]);
        $this->assertTrue($cond->completion_value_used($this->course, $page0->cmid));
        $this->assertTrue($cond->completion_value_used($this->course, $page1->cmid));
        $completion = new \completion_info($this->course);
        $completion->reset_all_state($modinfo->get_cm($page1->cmid));

        $cond = new condition((object)['type' => 'relativedate', 'n' => 4, 'd' => 4, 's' => 7, 'm' => $page0->cmid]);
        $this->assertTrue($cond->update_dependency_id('course_sections', $page0->cmid, 3));
        $this->assertFalse($cond->update_dependency_id('course_modules', $page1->cmid, 3));
        $cond = new condition((object)['type' => 'relativedate', 'n' => 4, 'd' => 4, 's' => 7, 'm' => $page1->cmid]);
        $this->assertTrue($cond->update_dependency_id('course_modules', $page1->cmid, 4));
        $this->assertFalse($cond->update_dependency_id('course_modules', $page1->cmid, -1));
    }

    /**
     * Tests a course with no enddate.
     * @covers \availability_relativedate\condition
     */
    public function test_no_enddate(): void {
        global $DB, $USER;
        $dg = $this->getDataGenerator();
        $now = time();
        $course1 = $dg->create_course(['enablecompletion' => 1]);
        $course2 = $dg->create_course(['enddate' => $now + 14 * WEEKSECS, 'enablecompletion' => 1]);
        $user = $dg->create_user();
        $roleid = $DB->get_field('role', 'id', ['shortname' => 'student']);
        $dg->enrol_user($user->id, $course1->id, $roleid);
        $dg->enrol_user($user->id, $course2->id, $roleid);
        $pg = $this->getDataGenerator()->get_plugin_generator('mod_page');
        $page1 = $pg->create_instance(['course' => $course1, 'completion' => COMPLETION_TRACKING_MANUAL]);
        $page2 = $pg->create_instance(['course' => $course2, 'completion' => COMPLETION_TRACKING_MANUAL]);
        $modinfo1 = get_fast_modinfo($course1);
        $modinfo2 = get_fast_modinfo($course2);
        $cm1 = $modinfo1->get_cm($page1->cmid);
        $cm2 = $modinfo2->get_cm($page2->cmid);
        $info = new info_module($cm1);
        $cond = new condition((object)['type' => 'relativedate', 'n' => 7, 'd' => 2, 's' => 2, 'm' => 1]);
        $information = $cond->get_description(true, false, $info);
        $this->assertEquals('This course has no end date', $information);
        $this->assertEquals('{relativedate: 7 days before course end date}', "$cond");
        // No enddate => Never available.
        $this->assertFalse($cond->is_available(false, $info, false, $user->id));
        $this->assertFalse($cond->is_available(true, $info, false, $user->id));
        $info = new info_module($cm2);
        $information = $cond->get_description(true, false, $info);
        $strf = get_string('strftimedatetime', 'langconfig');
        $this->assertStringNotContainsString('(No course enddate)', $information);
        $str = userdate($course2->enddate - (7 * 24 * 3600), $strf);
        $this->assertEquals("Until $str (7 days before course end date)", $information);
        $this->assertEquals('{relativedate: 7 days before course end date}', "$cond");
        $this->assertFalse($cond->is_available(false, $info, false, $user->id));
        $this->assertTrue($cond->is_available(true, $info, false, $user->id));
        $this->assertFalse($cond->is_available(false, $info, false, null));
        $this->assertTrue($cond->is_available(true, $info, false, null));

        $cond = new condition((object)['type' => 'relativedate', 'n' => 7, 'd' => 2, 's' => 3, 'm' => 1]);
        $information = $cond->get_description(true, false, $info);
        $this->assertEquals('(7 days after user enrolment date)', $information);
        $this->assertFalse($cond->is_available(false, $info, false, $USER->id));
        $this->assertFalse($cond->is_available(true, $info, false, $USER->id));

        $cond = new condition((object)['type' => 'relativedate', 'n' => 7, 'd' => 2, 's' => 4, 'm' => 1]);
        $information = $cond->get_description(false, false, $info);
        $this->assertEquals('(7 days after enrolment method end date)', $information);

        $info = new info_module($cm1);
        $cond = new condition((object)['type' => 'relativedate', 'n' => 7, 'd' => 2, 's' => 5, 'm' => 1]);
        $information = $cond->get_description(false, false, $info);
        $this->assertEquals('This course has no end date', $information);

        $cond = new condition((object)['type' => 'relativedate', 'n' => 7, 'd' => 2, 's' => 6, 'm' => 1]);
        $information = $cond->get_description(false, false, $info);
        $str = userdate($course2->startdate - (7 * 24 * 3600), $strf);
        $this->assertEquals("Until $str", $information);
        $this->assertEquals('{relativedate: 7 days before course start date}', "$cond");

        $cond = new condition((object)['type' => 'relativedate', 'n' => 7, 'd' => 2, 's' => 6, 'm' => 9999999]);
        $information = $cond->get_description(false, false, $info);
        $this->assertEquals("Until $str", $information);
        $this->assertEquals('{relativedate: 7 days before course start date}', "$cond");

        $cond = new condition((object)['type' => 'relativedate', 'n' => 7, 'd' => 2, 's' => 6, 'm' => -1]);
        $information = $cond->get_description(false, false, $info);
        $this->assertEquals("Until $str", $information);
        $this->assertEquals('{relativedate: 7 days before course start date}', "$cond");
    }

    /**
     * Tests debug strings (reflection).
     * @covers \availability_relativedate\condition
     */
    public function test_reflection_debug_strings(): void {
        $name = 'availability_relativedate\condition';
        $daybefore = ' 1 ' . get_string('day', 'availability_relativedate');
        $pg = self::getDataGenerator()->get_plugin_generator('mod_page');
        $page0 = $pg->create_instance(['course' => $this->course, 'completion' => COMPLETION_TRACKING_MANUAL]);

        $condition = new condition((object)['type' => 'relativedate', 'n' => 1, 'd' => 2, 's' => 7, 'm' => $page0->cmid]);
        $result = \phpunit_util::call_internal_method($condition, 'get_debug_string', [], $name);
        $this->assertEquals(
            $daybefore . ' ' .
            get_string('datecompletion', 'availability_relativedate')
            . ' ' . condition::description_cm_name($page0->cmid),
            $result
        );

        $condition = new condition((object)['type' => 'relativedate', 'n' => 1, 'd' => 2, 's' => 7, 'm' => 999999]);
        $result = \phpunit_util::call_internal_method($condition, 'get_debug_string', [], $name);
        $this->assertStringContainsString(get_string('missing', 'availability_relativedate'), $result);
    }

    /**
     * Tests a reflection.
     * @covers \availability_relativedate\condition
     */
    public function test_reflection_calc(): void {
        global $DB;
        $name = 'availability_relativedate\condition';
        $pg = self::getDataGenerator()->get_plugin_generator('mod_page');
        $page0 = $pg->create_instance(['course' => $this->course, 'completion' => COMPLETION_TRACKING_MANUAL]);
        $context = context_module::instance($page0->cmid);
        $activitycompletion = $this->create_course_module_completion($page0->cmid);
        $arr = [
            'objectid' => $activitycompletion->id,
            'relateduserid' => $this->user->id,
            'context' => $context,
        ];
        course_module_completion_updated::create($arr)->trigger();

        $condition1 = new condition((object)['type' => 'relativedate', 'n' => 1, 'd' => 2, 's' => 1, 'm' => 999999]);
        $result1 = \phpunit_util::call_internal_method($condition1, 'calc', [$this->course, $this->user->id], $name);
        $this->assertEquals($this->course->startdate + DAYSECS, $result1);

        $condition2 = new condition((object)['type' => 'relativedate', 'n' => 1, 'd' => 2, 's' => 2, 'm' => 999999]);
        $result2 = \phpunit_util::call_internal_method($condition2, 'calc', [$this->course, $this->user->id], $name);
        $this->assertEquals($this->course->enddate - DAYSECS, $result2);

        self::getDataGenerator()->enrol_user($this->user->id, $this->course->id);
        $enrol1 = $DB->get_record('user_enrolments', ['userid' => $this->user->id]);
        $condition31 = new condition((object)['type' => 'relativedate', 'n' => 1, 'd' => 2, 's' => 3, 'm' => 999999]);
        $result31 = \phpunit_util::call_internal_method($condition31, 'calc', [$this->course, $this->user->id], $name);
        $this->assertEquals($enrol1->timecreated + DAYSECS, $result31);

        $user2 = self::getDataGenerator()->create_user(['timezone' => 'UTC']);
        self::getDataGenerator()->enrol_user(
            $user2->id,
            $this->course->id,
            null,
            'manual',
            (int)$this->course->startdate + HOURSECS,
            (int)$this->course->startdate + HOURSECS * 24
        );
        $enrol2 = $DB->get_record('user_enrolments', ['userid' => $user2->id]);
        $condition32 = new condition((object)['type' => 'relativedate', 'n' => 1, 'd' => 2, 's' => 3, 'm' => 999999]);
        $result32 = \phpunit_util::call_internal_method($condition32, 'calc', [$this->course, $user2->id], $name);
        $this->assertEquals((int)$enrol2->timestart + DAYSECS, $result32);
        $this->assertEquals((int)$this->course->startdate + HOURSECS * 25, $result32);

        $courseself = $DB->get_record('enrol', ['courseid' => $this->course->id, 'enrol' => 'manual']);
        $courseself->enrolenddate = $this->course->enddate - 12 * HOURSECS;
        $DB->update_record('enrol', $courseself);
        $condition4 = new condition((object)['type' => 'relativedate', 'n' => 1, 'd' => 2, 's' => 4, 'm' => 999999]);
        $result4 = \phpunit_util::call_internal_method($condition4, 'calc', [$this->course, $this->user->id], $name);
        $this->assertEquals($courseself->enrolenddate + DAYSECS, $result4);

        $condition5 = new condition((object)['type' => 'relativedate', 'n' => 1, 'd' => 2, 's' => 5, 'm' => 999999]);
        $result5 = \phpunit_util::call_internal_method($condition5, 'calc', [$this->course, $this->user->id], $name);
        $this->assertEquals($this->course->enddate + DAYSECS, $result5);

        $condition6 = new condition((object)['type' => 'relativedate', 'n' => 1, 'd' => 2, 's' => 6, 'm' => 999999]);
        $result6 = \phpunit_util::call_internal_method($condition6, 'calc', [$this->course, $this->user->id], $name);
        $this->assertEquals($this->course->startdate - DAYSECS, $result6);

        $condition71 = new condition((object)['type' => 'relativedate', 'n' => 1, 'd' => 2, 's' => 7, 'm' => 0]);
        $result71 = \phpunit_util::call_internal_method($condition71, 'calc', [$this->course, $this->user->id], $name);
        $this->assertEquals(0, $result71);

        $condition72 = new condition((object)['type' => 'relativedate', 'n' => 1, 'd' => 2, 's' => 7, 'm' => $page0->cmid]);
        $result72 = \phpunit_util::call_internal_method($condition72, 'calc', [$this->course, $this->user->id], $name);
        $this->assertEquals($activitycompletion->timemodified + DAYSECS, $result72);

        $condition73 = new condition((object)['type' => 'relativedate', 'n' => 1, 'd' => 2, 's' => 7, 'm' => 999999]);
        $result73 = \phpunit_util::call_internal_method($condition73, 'calc', [$this->course, $this->user->id], $name);
        $this->assertEquals(0, $result73);
    }

    /**
     * Create course module completion.
     *
     * @param int $cmid course module id
     * @return stdClass
     */
    private function create_course_module_completion(int $cmid): stdClass {
        global $DB;
        $activitycompletion = new stdClass();
        $activitycompletion->coursemoduleid = $cmid;
        $activitycompletion->userid = $this->user->id;
        $activitycompletion->viewed = null;
        $activitycompletion->overrideby = null;
        $activitycompletion->completionstate = 1;
        $activitycompletion->timemodified = time();
        $activitycompletion->id = $DB->insert_record('course_modules_completion', $activitycompletion);
        return $activitycompletion;
    }

    /**
     * Tests the autoupdate event.
     * @covers \availability_relativedate\autoupdate
     */
    public function test_autoupdate(): void {
        global $DB;
        $pg = $this->getDataGenerator()->get_plugin_generator('mod_page');
        $page0 = $pg->create_instance(['course' => $this->course, 'completion' => COMPLETION_TRACKING_MANUAL]);
        $page1 = $pg->create_instance(['course' => $this->course, 'completion' => COMPLETION_TRACKING_MANUAL]);
        $str = '{"op":"|","show":true,"c":[{"type":"relativedate","n":4,"d":4,"s":7,"m":' . $page0->cmid . '}]}';
        $DB->set_field('course_modules', 'availability', $str, ['id' => $page1->cmid]);
        $this->do_cron();
        $event = \core\event\course_module_deleted::create([
            'objectid' => $page0->cmid,
            'relateduserid' => 1,
            'context' => \context_course::instance($this->course->id),
            'courseid' => $this->course->id,
            'other' => [
                'relateduserid' => 1,
                'modulename' => 'page',
                'instanceid' => $page0->cmid,
                'name' => $page0->name,
            ],
        ]);
        $event->trigger();

        $actual = $DB->get_record('course_modules', ['id' => $page1->cmid]);
        self::assertEquals(
            '{"op":"|","show":true,"c":[{"type":"relativedate","n":4,"d":4,"s":7,"m":-1}]}',
            $actual->availability
        );
    }

    /**
     * Cron function.
     * @coversNothing
     */
    private function do_cron(): void {
        $task = new \core\task\completion_regular_task();
        ob_start();
        $task->execute();
        sleep(1);
        $task->execute();
        \phpunit_util::run_all_adhoc_tasks();
        ob_end_clean();
        get_fast_modinfo(0, 0, true);
        rebuild_course_cache($this->course->id);
    }

    /**
     * Which date.
     * @coversNothing
     *
     * @param int $s
     * @return int
     */
    private function get_reldate($s): int {
        global $DB;
        switch ($s) {
            case 1:
            case 6:
                return $this->course->startdate;
            case 2:
            case 5:
                return $this->course->enddate;
            case 3:
            case 4:
                $now = time();
                $selfplugin = enrol_get_plugin('self');
                $instance = $DB->get_record('enrol', ['courseid' => $this->course->id, 'enrol' => 'self'], '*', MUST_EXIST);
                $DB->set_field('enrol', 'enrolenddate', $now + 1000, ['id' => $instance->id]);
                $instance = $DB->get_record('enrol', ['courseid' => $this->course->id, 'enrol' => 'self'], '*', MUST_EXIST);
                $selfplugin->enrol_user($instance, $this->user->id, 5, $now);
                return ($s === 3) ? $now : $now + 1000;
        }
        return 0;
    }
}