Proyectos de Subversion Moodle

use course_modinfo;

        // Create and enrol user using given role.

        $this->set_test_user_by_role($course, $role);

        // Some formats, like social, can create some initial activity.

        $modninfo = course_modinfo::instance($course);

        $cms = $modninfo->get_cms();

        $count = 0;

        foreach ($cms as $cm) {

            static::course_state_provider('singleactivity'),

            static::section_state_provider('singleactivity', 'admin'),

            static::section_state_provider('singleactivity', 'editingteacher'),

            static::section_state_provider('singleactivity', 'student'),

            static::cm_state_provider('singleactivity', 'admin'),

            static::cm_state_provider('singleactivity', 'editingteacher'),

            static::cm_state_provider('singleactivity', 'student'),

        $expectedexception = ($format === 'singleactivity');

        $cms = ['cm0', 'cm1', 'cm2', 'cm3'];

        // All sections and cms that the user can access to.

        $usersections = ['section0', 'section1', 'section2', 'section3'];

        $studentcms = ['cm0'];

        if ($format === 'social') {

            $cms = ['initialcm0', 'cm0', 'cm1', 'cm2', 'cm3'];

            $studentcms = ['initialcm0', 'cm0'];

            $usersections = ['section0']; // Social format only uses section 0 (for all users).

        }

        }

        if ($format === 'social') {

            $usercms = ['initialcm0', ...$usercms];

            $usersections = ['section0']; // Social format only uses section 0 (for all users).

        if ($format === 'social') {

            $usercms = ['initialcm0', ...$usercms];

            $usersections = ['section0']; // Social format only uses section 0 (for all users).

        }

    /**

     * Test course module move and subsection move.

     *

     * @covers ::cm_move

     * @dataProvider cm_move_provider

     * @param string[] $cmtomove the sections to move

     * @param string $targetsection

     * @param string[] $expectedcoursetree expected course tree

     * @param string|null $expectedexception if it will expect an exception.

     */

    public function test_cm_move(

        array $cmtomove,

        string $targetsection,

        array $expectedcoursetree,

        ?string $expectedexception = null

    ): void {

        $this->resetAfterTest();

        $course = $this->create_course('topics', 4, []);

        $subsection1 = $this->getDataGenerator()->create_module(

            'subsection', ['course' => $course, 'section' => 1, 'name' => 'subsection1']

        );

        $subsection2 = $this->getDataGenerator()->create_module(

            'subsection', ['course' => $course, 'section' => 1, 'name' => 'subsection2']

        );

        $modinfo = get_fast_modinfo($course);

        $subsection1info = $modinfo->get_section_info_by_component('mod_subsection', $subsection1->id);

        $subsection2info = $modinfo->get_section_info_by_component('mod_subsection', $subsection2->id);

        $references = $this->course_references($course);

        // Add some activities to the course. One visible and one hidden in both sections 1 and 2.

        $references["cm0"] = $this->create_activity($course->id, 'assign', 0);

        $references["cm1"] = $this->create_activity($course->id, 'page', 2);

        $references["cm2"] = $this->create_activity($course->id, 'forum', $subsection1info->sectionnum);

        $references["subsection1"] = intval($subsection1->cmid);

        $references["subsection2"] = intval($subsection2->cmid);

        $references["subsection1sectionid"] = $subsection1info->id;

        $references["subsection2sectionid"] = $subsection2info->id;

        $user = $this->getDataGenerator()->create_user();

        $this->getDataGenerator()->enrol_user($user->id, $course->id, 'editingteacher');

        $this->setUser($user);

        // Initialise stateupdates.

        $courseformat = course_get_format($course->id);

        $updates = new stateupdates($courseformat);

        if ($expectedexception) {

            $this->expectExceptionMessage($expectedexception);

        }

        // Execute the method.

        $actions = new stateactions();

        // We do this to make sure we can reference subsection1 in the course tree (and not just section5 as subsection1 is

        // both a module and a subsection).

        if (str_starts_with($targetsection, 'subsection')) {

            $targetsection = $targetsection . 'sectionid';

        }

        $actions->cm_move(

            $updates,

            $course,

            $this->translate_references($references, $cmtomove),

            $references[$targetsection]

        );

        $coursetree = $this->get_course_tree($course, $references);

        $this->assertEquals($expectedcoursetree, $coursetree);

    }

    /**

     * Get Course tree for later comparison.

     *

     * @param stdClass $course

     * @param array $references

     * @return array

     */

    private function get_course_tree(stdClass $course, array $references): array {

        $coursetree = [];

        $modinfo = get_fast_modinfo($course); // Get refreshed version.

        $allsections = $modinfo->get_listed_section_info_all();

        $cmidstoref = array_flip($references);

        foreach ($allsections as $sectioninfo) {

            $sectionkey = 'section' . $sectioninfo->sectionnum;

            $coursetree[$sectionkey] = [];

            if (empty(trim($sectioninfo->sequence))) {

                continue;

            }

            $cmids = explode(",", $sectioninfo->sequence);

            foreach ($cmids as $cmid) {

                $cm = $modinfo->get_cm($cmid);

                $delegatedsection = $cm->get_delegated_section_info();

                // Course modules without a delegated section are included as activities.

                if (!$delegatedsection) {

                    $coursetree[$sectionkey][] = $cmidstoref[$cmid];

                    continue;

                }

                // Course modules with a delegated are included as a section, not as an activity.

                $delegatedsectionkey = $delegatedsection->name; // We gave it a name, so let's use it as key.

                $coursetree[$sectionkey][$delegatedsectionkey] = [];

                if (empty(trim($delegatedsection->sequence))) {

                    continue;

                }

                $delegatedcmids = explode(",", $delegatedsection->sequence);

                foreach ($delegatedcmids as $dcmid) {

                    $coursetree[$sectionkey][$delegatedsectionkey][] = $cmidstoref[$dcmid];

                }

            }

        }

        return $coursetree;

    }

    /**

     * Provider for test_section_move.

     *

     *

     * The original coursetree looks like this:

     * 'coursetree' => [

     *    'section0' => ['cm0'],

     *    'section1' => ['subsection1' => ['cm2'],'subsection2' => []],

     *    'section2' => ['cm1'],

     *    'section3' => [],

     *    'section4' => [],

     * ],

     *

     * @return array the testing scenarios

     */

    public static function cm_move_provider(): array {

        return [

            'Move module into section2' => [

                'cmtomove' => ['cm0'],

                'targetsection' => 'section2',

                'expectedcoursetree' => [

                    'section0' => [],

                    'section1' => ['subsection1' => ['cm2'], 'subsection2' => []],

                    'section2' => ['cm1', 'cm0'],

                    'section3' => [],

                    'section4' => [],

                ],

            ],

            'Move subsection into another subsection' => [

                'cmtomove' => ['subsection1'], // When moving a subsection we actually move the delegated module.

                'targetsection' => 'subsection2',

                'expectedcoursetree' => [],

                'expectedexception' => 'error/subsectionmoveerror',

            ],

            'Move module into subsection' => [

                'cmtomove' => ['cm1'],

                'targetsection' => 'subsection1',

                'expectedcoursetree' => [

                    'section0' => ['cm0'],

                    'section1' => ['subsection1' => ['cm2', 'cm1'], 'subsection2' => []],

                    'section2' => [],

                    'section3' => [],

                    'section4' => [],

                ],

            ],

        ];

    }

    /**

     * Test that set_cm_indentation on activities with a delegated section.

     *

     * @covers ::set_cm_indentation

     */

    public function test_set_cm_indentation_delegated_section(): void {

        global $DB;

        $this->resetAfterTest();

        $this->setAdminUser();

        $course = $this->getDataGenerator()->create_course();

        $subsection = $this->getDataGenerator()->create_module('subsection', ['course' => $course]);

        $otheractvity = $this->getDataGenerator()->create_module('forum', ['course' => $course]);

        $this->setAdminUser();

        // Initialise stateupdates.

        $courseformat = course_get_format($course->id);

        // Execute given method.

        $updates = new stateupdates($courseformat);

        $actions = new stateactions();

        $actions->cm_moveright(

            $updates,

            $course,

            [$subsection->cmid, $otheractvity->cmid],

        );

        // Format results in a way we can compare easily.

        $results = $this->summarize_updates($updates);

        // The state actions does not use create or remove actions because they are designed

        // to refresh parts of the state.

        $this->assertEquals(0, $results['create']['count']);

        $this->assertEquals(0, $results['remove']['count']);

        // Mod subsection should be ignored.

        $this->assertEquals(1, $results['put']['count']);

        // Validate course, section and cm.

        $this->assertArrayHasKey($otheractvity->cmid, $results['put']['cm']);

        $this->assertArrayNotHasKey($subsection->cmid, $results['put']['cm']);

        // Validate activity indentation.

        $mondinfo = get_fast_modinfo($course);

        $this->assertEquals(1, $mondinfo->get_cm($otheractvity->cmid)->indent);

        $this->assertEquals(1, $DB->get_field('course_modules', 'indent', ['id' => $otheractvity->cmid]));

        $this->assertEquals(0, $mondinfo->get_cm($subsection->cmid)->indent);

        $this->assertEquals(0, $DB->get_field('course_modules', 'indent', ['id' => $subsection->cmid]));

        // Now move left.

        $updates = new stateupdates($courseformat);

        $actions->cm_moveleft(

            $updates,

            $course,

            [$subsection->cmid, $otheractvity->cmid],

        );

        // Format results in a way we can compare easily.

        $results = $this->summarize_updates($updates);

        // The state actions does not use create or remove actions because they are designed

        // to refresh parts of the state.

        $this->assertEquals(0, $results['create']['count']);

        $this->assertEquals(0, $results['remove']['count']);

        // Mod subsection should be ignored.

        $this->assertEquals(1, $results['put']['count']);

        // Validate course, section and cm.

        $this->assertArrayHasKey($otheractvity->cmid, $results['put']['cm']);

        $this->assertArrayNotHasKey($subsection->cmid, $results['put']['cm']);

        // Validate activity indentation.

        $mondinfo = get_fast_modinfo($course);

        $this->assertEquals(0, $mondinfo->get_cm($otheractvity->cmid)->indent);

        $this->assertEquals(0, $DB->get_field('course_modules', 'indent', ['id' => $otheractvity->cmid]));

        $this->assertEquals(0, $mondinfo->get_cm($subsection->cmid)->indent);

        $this->assertEquals(0, $DB->get_field('course_modules', 'indent', ['id' => $subsection->cmid]));

    }

    /**

     * Test for filter_cms_with_section_delegate protected method.

     *

     * @covers ::filter_cms_with_section_delegate

     */

    public function test_filter_cms_with_section_delegate(): void {

        $this->resetAfterTest();

        $this->setAdminUser();

        $course = $this->getDataGenerator()->create_course();

        $subsection = $this->getDataGenerator()->create_module('subsection', ['course' => $course]);

        $otheractvity = $this->getDataGenerator()->create_module('forum', ['course' => $course]);

        $this->setAdminUser();

        $courseformat = course_get_format($course->id);

        $modinfo = $courseformat->get_modinfo();

        $subsectioninfo = $modinfo->get_cm($subsection->cmid);

        $otheractvityinfo = $modinfo->get_cm($otheractvity->cmid);

        $actions = new stateactions();

        $method = new ReflectionMethod($actions, 'filter_cms_with_section_delegate');

        $result = $method->invoke($actions, [$subsectioninfo, $otheractvityinfo]);

        $this->assertCount(1, $result);

        $this->assertArrayHasKey($otheractvity->cmid, $result);

        $this->assertArrayNotHasKey($subsection->cmid, $result);

        $this->assertEquals($otheractvityinfo, $result[$otheractvityinfo->id]);

    }

    /**

     * Test for create_module public method.

     *

     * @covers ::create_module

     */

    public function test_create_module(): void {

        $this->resetAfterTest();

        $modname = 'subsection';

        $manager = \core_plugin_manager::resolve_plugininfo_class('mod');

        $manager::enable_plugin($modname, 1);

        // Create a course with 1 section and 1 student.

        $course = $this->getDataGenerator()->create_course(['numsections' => 1]);

        $courseformat = course_get_format($course->id);

        $targetsection = $courseformat->get_modinfo()->get_section_info(1);

        $this->setAdminUser();

        // Sanity check.

        $this->assertEmpty($courseformat->get_modinfo()->get_cms());

        // Execute given method.

        $actions = new stateactions();

        $updates = new stateupdates($courseformat);

        $actions->create_module($updates, $course, $modname, $targetsection->sectionnum);

        // Validate cm was created and updates were generated.

        $results = $this->summarize_updates($updates);

        $cmupdate = reset($results['put']['cm']);

        $this->assertCount(1, $courseformat->get_modinfo()->get_cms());

        $this->assertEquals($modname, $cmupdate->module);

        $this->assertEquals($targetsection->id, $cmupdate->sectionid);

        $this->assertEquals(get_string('quickcreatename', 'mod_' . $modname), $cmupdate->name);

        $this->assertDebuggingCalled();

    }

    /**

     * Test for create_module public method with no capabilities.

     *

     * @covers ::create_module

     */

    public function test_create_module_no_capabilities(): void {

        $this->resetAfterTest();

        $modname = 'subsection';

        // Create a course with 1 section and 1 student.

        $course = $this->getDataGenerator()->create_course(['numsections' => 1]);

        $student = $this->getDataGenerator()->create_user();

        $this->getDataGenerator()->enrol_user($student->id, $course->id, 'student');

        $courseformat = course_get_format($course->id);

        $targetsection = $courseformat->get_modinfo()->get_section_info(1);

        $this->setAdminUser();

        // Sanity check.

        $this->assertEmpty($courseformat->get_modinfo()->get_cms());

        // Change to a user without permission.

        $this->setUser($student);

        // Validate that the method throws an exception.

        $actions = new stateactions();

        $updates = new stateupdates($courseformat);

        // Capturing exceptions on deprecated methods is tricky because expectException is executed

        // before assertDebuggingCalled. We need to use try catch in a creative way.

        try {

            $actions->create_module($updates, $course, $modname, $targetsection->sectionnum);

        } catch (moodle_exception $exception) {

            $this->assertDebuggingCalled();

            $this->expectException(moodle_exception::class);

            throw $exception;

        }

    }

    /**

     * Test for create_module public method with targetcmid parameter.

     *

     * @covers ::create_module

     */

    public function test_create_module_with_targetcmid(): void {

        $this->resetAfterTest();

        $modname = 'subsection';

        $manager = \core_plugin_manager::resolve_plugininfo_class('mod');

        $manager::enable_plugin($modname, 1);

        // Create a course with 1 section, 2 modules (forum and page) and 1 student.

        $course = $this->getDataGenerator()->create_course(['numsections' => 1]);

        $forum = $this->getDataGenerator()->create_module('forum', ['course' => $course], ['section' => 1]);

        $page = $this->getDataGenerator()->create_module('page', ['course' => $course], ['section' => 1]);

        $student = $this->getDataGenerator()->create_user();

        $this->getDataGenerator()->enrol_user($student->id, $course->id, 'student');

        $courseformat = course_get_format($course->id);

        $targetsection = $courseformat->get_modinfo()->get_section_info(1);

        $this->setAdminUser();

        // Sanity check.

        $this->assertCount(2, $courseformat->get_modinfo()->get_cms());

        // Execute given method.

        $actions = new stateactions();

        $updates = new stateupdates($courseformat);

        $actions->create_module($updates, $course, $modname, $targetsection->sectionnum, $page->cmid);

        $modinfo = $courseformat->get_modinfo();

        $cms = $modinfo->get_cms();

        $results = $this->summarize_updates($updates);

        $cmupdate = reset($results['put']['cm']);

        // Validate updates were generated.

        $this->assertEquals($modname, $cmupdate->module);

        $this->assertEquals($targetsection->id, $cmupdate->sectionid);

        $this->assertEquals(get_string('quickcreatename', 'mod_' . $modname), $cmupdate->name);

        // Validate that the new module was created between both modules.

        $this->assertCount(3, $cms);

        $this->assertArrayHasKey($cmupdate->id, $cms);

        $this->assertEquals(

            implode(',', [$forum->cmid, $cmupdate->id, $page->cmid]),

            $modinfo->get_section_info(1)->sequence

        );

        $this->assertDebuggingCalled();

    }

    /**

     * Test for new_module public method.

     *

     * @covers ::new_module

     */

    public function test_new_module(): void {

        $this->resetAfterTest();

        $modname = 'subsection';

        // Create a course with 1 section and 1 student.

        $course = $this->getDataGenerator()->create_course(['numsections' => 1]);

        $courseformat = course_get_format($course->id);

        $targetsection = $courseformat->get_modinfo()->get_section_info(1);

        $this->setAdminUser();

        // Sanity check.

        $this->assertEmpty($courseformat->get_modinfo()->get_cms());

        // Execute given method.

        $actions = new stateactions();

        $updates = new stateupdates($courseformat);

        $actions->new_module($updates, $course, $modname, $targetsection->id);

        // Validate cm was created and updates were generated.

        $results = $this->summarize_updates($updates);

        $cmupdate = reset($results['put']['cm']);

        $this->assertCount(1, $courseformat->get_modinfo()->get_cms());

        $this->assertEquals($modname, $cmupdate->module);

        $this->assertEquals($targetsection->id, $cmupdate->sectionid);

        $this->assertEquals(get_string('quickcreatename', 'mod_' . $modname), $cmupdate->name);

    }

    /**

     * Test for new_module public method with no capabilities.

     *

     * @covers ::new_module

     */

    public function test_new_module_no_capabilities(): void {

        $this->resetAfterTest();

        $modname = 'subsection';

        // Create a course with 1 section and 1 student.

        $course = $this->getDataGenerator()->create_course(['numsections' => 1]);

        $student = $this->getDataGenerator()->create_user();

        $this->getDataGenerator()->enrol_user($student->id, $course->id, 'student');

        $courseformat = course_get_format($course->id);

        $targetsection = $courseformat->get_modinfo()->get_section_info(1);

        $this->setAdminUser();

        // Sanity check.

        $this->assertEmpty($courseformat->get_modinfo()->get_cms());

        // Change to a user without permission.

        $this->setUser($student);

        // Validate that the method throws an exception.

        $actions = new stateactions();

        $updates = new stateupdates($courseformat);

        $this->expectException(moodle_exception::class);

        $actions->new_module($updates, $course, $modname, $targetsection->id);

    }

    /**

     * Test for new_module public method with targetcmid parameter.

     *

     * @covers ::new_module

     */

    public function test_new_module_with_targetcmid(): void {

        $this->resetAfterTest();

        $modname = 'subsection';

        // Create a course with 1 section, 2 modules (forum and page) and 1 student.

        $course = $this->getDataGenerator()->create_course(['numsections' => 1]);

        $forum = $this->getDataGenerator()->create_module('forum', ['course' => $course], ['section' => 1]);

        $page = $this->getDataGenerator()->create_module('page', ['course' => $course], ['section' => 1]);

        $student = $this->getDataGenerator()->create_user();

        $this->getDataGenerator()->enrol_user($student->id, $course->id, 'student');

        $courseformat = course_get_format($course->id);

        $targetsection = $courseformat->get_modinfo()->get_section_info(1);

        $this->setAdminUser();

        // Sanity check.

        $this->assertCount(2, $courseformat->get_modinfo()->get_cms());

        // Execute given method.

        $actions = new stateactions();

        $updates = new stateupdates($courseformat);

        $actions->new_module($updates, $course, $modname, $targetsection->id, $page->cmid);

        $modinfo = $courseformat->get_modinfo();

        $cms = $modinfo->get_cms();

        $results = $this->summarize_updates($updates);

        $cmupdate = reset($results['put']['cm']);

        // Validate updates were generated.

        $this->assertEquals($modname, $cmupdate->module);

        $this->assertEquals($targetsection->id, $cmupdate->sectionid);

        $this->assertEquals(get_string('quickcreatename', 'mod_' . $modname), $cmupdate->name);

        // Validate that the new module was created between both modules.

        $this->assertCount(3, $cms);

        $this->assertArrayHasKey($cmupdate->id, $cms);

        $this->assertEquals(

            implode(',', [$forum->cmid, $cmupdate->id, $page->cmid]),

            $modinfo->get_section_info(1)->sequence

        );

    }