Proyectos de Subversion Moodle

        $generator->create_module('page', ['course' => $course, 'section' => $originalsection->section]);

        $newmodcount = $DB->count_records('course_modules', ['course' => $course->id, 'section' => $newsection->id]);

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

        $qbankinstances = $modinfo->get_instances_of('qbank');

        $this->assertEquals($originalmodcount - 1, $newmodcount);

    }

    /**

     * Test duplicate_section() with delegated section

     * @covers     ::duplicate_section

     */

    public function test_duplicate_section_with_delegated_sections(): void {

        global $DB;

        $this->setAdminUser();

        $this->resetAfterTest();

        // Add subsection.

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

        $manager::enable_plugin('subsection', 1);

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

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

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

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

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

        $format = course_get_format($course);

        $modinfo = get_fast_modinfo($course);

        $sectioninfo = $modinfo->get_section_info(1, MUST_EXIST);

        $originalsectioncount = $DB->count_records('course_sections', ['course' => $course->id]);

        $this->assertEquals(4, $originalsectioncount);

        $originalsection = $DB->get_record('course_sections',

            ['course' => $course->id, 'section' => 0],

            '*',

            MUST_EXIST);

        $newsection = $format->duplicate_section($sectioninfo);

        foreach ($originalsection as $prop => $value) {

            if ($prop == 'id' || $prop == 'sequence' || $prop == 'section' || $prop == 'timemodified') {

                continue;

            }

            $this->assertEquals($value, $newsection->$prop);

        }

        $sectioncount = $DB->count_records('course_sections', ['course' => $course->id]);

        $result = $format->get_non_ajax_cm_action_url($action, $cminfo);

        if (!$exception) {

            $this->assertDebuggingCalled();

    }

    public function test_is_section_visible(): void {

        $this->resetAfterTest();

        $generator = $this->getDataGenerator();

        $course = $generator->create_course(['format' => 'testformatsections'], ['hiddensections' => 1]);

        course_create_sections_if_missing($course, [0, 1, 2]);

        // Students cannot view hidden sections.

        $sectioninfo = get_fast_modinfo($course)->get_section_info(1);

        \core_courseformat\formatactions::section($course)->update($sectioninfo, ['visible' => false]);

        $format = course_get_format($course);

        // Force max sections to 1 to detect section 2 as orphan.

        $format->forcemaxsections = 1;

        $teacher = $this->getDataGenerator()->create_and_enrol($course, 'editingteacher');

        $student = $this->getDataGenerator()->create_and_enrol($course, 'student');

        $this->setUser($teacher);

        $modinfoteacher = get_fast_modinfo($course, $teacher->id);

        $this->assertTrue($format->is_section_visible($modinfoteacher->get_section_info(0)));

        $this->assertTrue($format->is_section_visible($modinfoteacher->get_section_info(1)));

        $this->assertTrue($format->is_section_visible($modinfoteacher->get_section_info(2)));

        $this->setUser($student);

        $modinfostudent = get_fast_modinfo($course, $student->id);

        $this->assertTrue($format->is_section_visible($modinfostudent->get_section_info(0)));

        $this->assertFalse($format->is_section_visible($modinfostudent->get_section_info(1)));

        $this->assertFalse($format->is_section_visible($modinfostudent->get_section_info(2)));

    }

    /**

     * Test for the get_generic_section_name method.

     *

     * @covers ::get_generic_section_name

     */

    public function test_get_generic_section_name(): void {

        $this->resetAfterTest();

        $generator = $this->getDataGenerator();

        $course1 = $generator->create_course(['format' => 'topics']);

        $course2 = $generator->create_course(['format' => 'theunittest']);

        $format = course_get_format($course1);

        $this->assertEquals(

            get_string('sectionname', 'format_topics'),

            $format->get_generic_section_name()

        );

        $format = course_get_format($course2);

        $this->assertEquals(

            get_string('section'),

            $format->get_generic_section_name()

        );

    }

    /**

     * Test can_sections_be_removed_from_navigation().

     *

     * @covers ::session_cache

     * @covers ::session_cache_reset

     * @covers ::session_cache_reset_all

     * @covers ::invalidate_all_session_caches_for_course

     */

    public function test_session_caches_methods(): void {

        global $DB;

        $this->resetAfterTest();

        $generator = $this->getDataGenerator();

        $course1 = $generator->create_course(['format' => 'topics']);

        $course2 = $generator->create_course(['format' => 'topics']);

        // Force some cacherev to the course.

        $course1->cacherev = 12345;

        $course2->cacherev = 67890;

        $DB->set_field('course', 'cacherev', $course1->cacherev, ['id' => $course1->id]);

        $DB->set_field('course', 'cacherev', $course2->cacherev, ['id' => $course2->id]);

        $teacher = $generator->create_and_enrol($course1, 'editingteacher');

        $generator->enrol_user($teacher->id, $course2->id, 'editingteacher');

        $this->setUser($teacher);

        // The cache key uses time() as hash. To not wait a second between calls we fake an initial value.

        $statecache = cache::make('core', 'courseeditorstate');

        $statecache->set($course1->id, $course1->cacherev . '_11111');

        $statecache->set($course2->id, $course2->cacherev . '_22222');

        $course1cachekey = \core_courseformat\base::session_cache($course1);

        // Validate the method returns the same value when called twice.

        $course1cachekeyagain = \core_courseformat\base::session_cache($course1);

        $this->assertEquals($course1cachekey, $course1cachekeyagain);

        // Validate other course has a diferent cache key.

        $course2cachekey = \core_courseformat\base::session_cache($course2);

        $this->assertNotEquals($course1cachekey, $course2cachekey);

        // Reset the specific course cache.

        \core_courseformat\base::session_cache_reset($course1);

        $resetcachekey = \core_courseformat\base::session_cache($course1);

        $this->assertNotEquals($course1cachekey, $resetcachekey);

        $reset2cachekey = \core_courseformat\base::session_cache($course2);

        $this->assertEquals($course2cachekey, $reset2cachekey);

        // Return to the initial value.

        $statecache->set($course1->id, $course1->cacherev . '_11111');

        $statecache->set($course2->id, $course2->cacherev . '_22222');

        // Reset all user course caches.

        \core_courseformat\base::session_cache_reset_all();

        $resetallcachekey = \core_courseformat\base::session_cache($course1);

        $this->assertNotEquals($course1cachekey, $resetallcachekey);

        $resetall2cachekey = \core_courseformat\base::session_cache($course2);

        $this->assertNotEquals($course2cachekey, $resetall2cachekey);

        // Return to the initial value.

        $statecache->set($course1->id, $course1->cacherev . '_11111');

        $statecache->set($course2->id, $course2->cacherev . '_22222');

        // Invalidate cache on course 1.

        \core_courseformat\base::invalidate_all_session_caches_for_course($course1);

        $invalidatecachekey = \core_courseformat\base::session_cache($course1);

        $this->assertNotEquals($course1cachekey, $invalidatecachekey);

        $invalidate2cachekey = \core_courseformat\base::session_cache($course2);

        $this->assertEquals($course2cachekey, $invalidate2cachekey);

     * @var int|null $forcemaxsections The maximum number of sections.

     */

    public ?int $forcemaxsections = null;

    /**

    }

    public function get_last_section_number(): int {

        if ($this->forcemaxsections !== null) {

            return $this->forcemaxsections;

        }

        return parent::get_last_section_number();