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

/**

 * BBB Library tests class trait.

 *

 * @package   mod_bigbluebuttonbn

 * @copyright 2018 - present, Blindside Networks Inc

 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 * @author    Laurent David (laurent@call-learning.fr)

 */

namespace mod_bigbluebuttonbn\test;

use context_module;

use mod_bigbluebuttonbn\instance;

use mod_bigbluebuttonbn\local\config;

use mod_bigbluebuttonbn\local\proxy\recording_proxy;

use mod_bigbluebuttonbn\meeting;

use stdClass;

use testing_data_generator;

use core\plugininfo\mod;

trait testcase_helper_trait {

    /** @var testing_data_generator|null */

    protected $generator = null;

    /** @var object|null */

    protected $course = null;

    /**

     * Convenience function to create an instance of a bigbluebuttonactivty.

     *

     * @param stdClass|null $course course to add the module to

     * @param array $params Array of parameters to pass to the generator

     * @param array $options Array of options to pass to the generator

     * @return array($context, $cm, $instance) Testable wrapper around the assign class.

     */

    protected function create_instance(?stdClass $course = null, array $params = [], array $options = []): array {

        // Prior to creating the instance, make sure that the BigBlueButton module is enabled.

        $modules = \core_plugin_manager::instance()->get_plugins_of_type('mod');

        if (!$modules['bigbluebuttonbn']->is_enabled()) {

            mod::enable_plugin('bigbluebuttonbn', true);

        }

        if (!$course) {

            $course = $this->get_course();

        }

        $params['course'] = $course->id;

        $options['visible'] = 1;

        $instance = $this->getDataGenerator()->create_module('bigbluebuttonbn', $params, $options);

        list($course, $cm) = get_course_and_cm_from_instance($instance, 'bigbluebuttonbn');

        $context = context_module::instance($cm->id);

        return [$context, $cm, $instance];

    }

    /**

     * Get the matching form data

     *

     * @param stdClass $bbactivity the current bigbluebutton activity

     * @param stdClass|null $course the course or null (taken from $this->get_course() if null)

     * @return mixed

     */

    protected function get_form_data_from_instance(stdClass $bbactivity, ?stdClass $course = null): object {

        global $USER;

        if (!$course) {

            $course = $this->get_course();

        }

        $this->setAdminUser();

        $bbactivitycm = get_coursemodule_from_instance('bigbluebuttonbn', $bbactivity->id);

        list($cm, $context, $module, $data, $cw) = get_moduleinfo_data($bbactivitycm, $course);

        $this->setUser($USER);

        return $data;

    }

    /**

     * Get or create course if it does not exist

     *

     * @return stdClass|null

     */

    protected function get_course(): stdClass {

        if (!$this->course) {

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

        }

        return $this->course;

    }

    /**

     * Generate a course, several students and several groups

     *

     * @param stdClass $courserecord

     * @param int $numstudents

     * @param int $numteachers

     * @param int $groupsnum

     * @return array

     */

    protected function setup_course_students_teachers(stdClass $courserecord, int $numstudents, int $numteachers,

        int $groupsnum): array {

        global $DB;

        $generator = $this->getDataGenerator();

        $course = $generator->create_course($courserecord);

        $groups = [];

        for ($i = 0; $i < $groupsnum; $i++) {

            $groups[] = $generator->create_group(['courseid' => $course->id]);

        }

        $generator->create_group(['courseid' => $course->id]);

        $generator->create_group(['courseid' => $course->id]);

        $roleids = $DB->get_records_menu('role', null, '', 'shortname, id');

        $students = [];

        for ($i = 0; $i < $numstudents; $i++) {

            $student = $generator->create_user();

            $generator->enrol_user($student->id, $course->id, $roleids['student']);

            $groupid = $groups[$i % $groupsnum]->id;

            groups_add_member($groupid, $student->id);

            $students[] = $student;

        }

        $teachers = [];

        for ($i = 0; $i < $numteachers; $i++) {

            $teacher = $generator->create_user();

            $generator->enrol_user($teacher->id, $course->id, $roleids['teacher']);

            $groupid = $groups[$i % $groupsnum]->id;

            groups_add_member($groupid, $teacher->id);

            $teachers[] = $teacher;

        }

        $bbactivity = $generator->create_module(

            'bigbluebuttonbn',

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

            ['visible' => true]);

        get_fast_modinfo(0, 0, true);

        return [$course, $groups, $students, $teachers, $bbactivity, $roleids];

    }

    /**

     * This test requires mock server to be present.

     */

    protected function initialise_mock_server(): void {

        if (!defined('TEST_MOD_BIGBLUEBUTTONBN_MOCK_SERVER')) {

            $this->markTestSkipped(

                'The TEST_MOD_BIGBLUEBUTTONBN_MOCK_SERVER constant must be defined to run mod_bigbluebuttonbn tests'

            );

        }

        try {

            $this->getDataGenerator()->get_plugin_generator('mod_bigbluebuttonbn')->reset_mock();

            // Mock server expects a value. By default this field is empty.

            set_config('bigbluebuttonbn_shared_secret', config::DEFAULT_SHARED_SECRET);

        } catch (\moodle_exception $e) {

            $this->markTestSkipped(

                'Cannot connect to the mock server for this test. Make sure that TEST_MOD_BIGBLUEBUTTONBN_MOCK_SERVER points

                to an active Mock server'

            );

        }

    }

    /**

     * Create an return an array of recordings

     *

     * @param instance $instance

     * @param array $recordingdata array of recording information

     * @param array $additionalmeetingdata

     * @return array

     */

    protected function create_recordings_for_instance(instance $instance, array $recordingdata = [],

        $additionalmeetingdata = []): array {

        $recordings = [];

        $bbbgenerator = $this->getDataGenerator()->get_plugin_generator('mod_bigbluebuttonbn');

        // Create the meetings on the mock server, so like this we can find the recordings.

        $meeting = new meeting($instance);

        $meeting->update_cache(); // The meeting has just been created but we need to force fetch info from the server.

        if (!$meeting->is_running()) {

            $additionalmeetingdata = array_merge([

                'instanceid' => $instance->get_instance_id(),

                'groupid' => $instance->get_group_id()

            ], $additionalmeetingdata);

            $bbbgenerator->create_meeting($additionalmeetingdata);

        }

        foreach ($recordingdata as $rindex => $data) {

            $recordings[] = $bbbgenerator->create_recording(

                array_merge([

                    'bigbluebuttonbnid' => $instance->get_instance_id(),

                    'groupid' => $instance->get_group_id()

                ], $data)

            );

        }

        return $recordings;

    }

    /**

     * Create an activity which includes a set of recordings.

     *

     * @param stdClass $course

     * @param int $type

     * @param array $recordingdata array of recording information

     * @param int $groupid

     * @return array

     */

    protected function create_activity_with_recordings(stdClass $course, int $type, array $recordingdata, int $groupid = 0): array {

        $generator = $this->getDataGenerator()->get_plugin_generator('mod_bigbluebuttonbn');

        $activity = $generator->create_instance([

            'course' => $course->id,

            'type' => $type

        ]);

        $instance = instance::get_from_instanceid($activity->id);

        $instance->set_group_id($groupid);

        $recordings = $this->create_recordings_for_instance($instance, $recordingdata);

        return [

            'course' => $course,

            'activity' => $activity,

            'recordings' => $recordings,

        ];

    }

    /**

     * Create a course, users and recording from dataset given in an array form

     *

     * @param array $dataset

     * @return mixed

     */

    protected function create_from_dataset(array $dataset) {

        list('type' => $type, 'recordingsdata' => $recordingsdata, 'groups' => $groups,

            'users' => $users) = $dataset;

        $plugingenerator = $this->getDataGenerator()->get_plugin_generator('mod_bigbluebuttonbn');

        $coursedata = empty($groups) ? [] : ['groupmodeforce' => true, 'groupmode' => $dataset['coursemode'] ?? VISIBLEGROUPS];

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

        foreach ($users as $userdata) {

            $this->getDataGenerator()->create_and_enrol($this->course, $userdata['role'], ['username' => $userdata['username']]);

        }

        if ($groups) {

            foreach ($groups as $groupname => $students) {

                $group = $this->getDataGenerator()->create_group(['name' => $groupname, 'courseid' => $this->course->id]);

                foreach ($students as $username) {

                    $user = \core_user::get_user_by_username($username);

                    $this->getDataGenerator()->create_group_member(['userid' => $user->id, 'groupid' => $group->id]);

                }

            }

        }

        $instancesettings = [

            'course' => $this->course->id,

            'type' => $type,

            'name' => 'Example',

        ];

        if (!empty($dataset['additionalsettings'])) {

            $instancesettings = array_merge($instancesettings, $dataset['additionalsettings']);

        }

        $activity = $plugingenerator->create_instance($instancesettings);

        $instance = instance::get_from_instanceid($activity->id);

        foreach ($recordingsdata as $groupname => $recordings) {

            if ($groups) {

                $groupid = groups_get_group_by_name($this->course->id, $groupname);

                $instance->set_group_id($groupid);

            }

            $this->create_recordings_for_instance($instance, $recordings);

        }

        return $activity->id;

    }

    /**

     * Create the legacy log entries for this task.

     *

     * @param instance $instance

     * @param int $userid

     * @param int $count

     * @param bool $importedrecordings

     * @param bool $withremoterecordings create recording on the mock server ?

     * @return array

     */

    protected function create_log_entries(

        instance $instance,

        int $userid,

        int $count = 30,

        bool $importedrecordings = false,

        bool $withremoterecordings = true

    ): array {

        // Create log entries for each (30 for the ungrouped, 30 for the grouped).

        $baselogdata = [

            'courseid' => $instance->get_course_id(),

            'userid' => $userid,

            'log' => $importedrecordings ? 'Import' : 'Create',

            'meta' => json_encode(['record' => true]),

            'imported' => $importedrecordings,

        ];

        $plugingenerator = $this->getDataGenerator()->get_plugin_generator('mod_bigbluebuttonbn');

        for ($i = 0; $i < $count; $i++) {

            if ($withremoterecordings) {

                // Create a recording.

                $starttime = time() - random_int(HOURSECS, WEEKSECS);

                $recording = $plugingenerator->create_recording([

                    'bigbluebuttonbnid' => $instance->get_instance_id(),

                    'groupid' => $instance->get_group_id(),

                    'starttime' => $starttime,

                    'endtime' => $starttime + HOURSECS,

                ], true); // Create them on the server only.

                $baselogdata['meetingid'] = $instance->get_meeting_id();

                if ($importedrecordings) {

                    // Fetch the data.

                    $data = recording_proxy::fetch_recordings([$recording->recordingid]);

                    $data = end($data);

                    if ($data) {

                        $metaonly = array_filter($data, function($key) {

                            return strstr($key, 'meta_');

                        }, ARRAY_FILTER_USE_KEY);

                    } else {

                        $data = [];

                    }

                    $baselogdata['meta'] = json_encode(array_merge([

                        'recording' => array_diff_key($data, $metaonly),

                    ], $metaonly));

                } else {

                    $baselogdata['meta'] = json_encode((object) ['record' => true]);

                }

            }

            // Insert the legacy log entry.

            $logs[] = $plugingenerator->create_log(array_merge($baselogdata, [

                'bigbluebuttonbnid' => $instance->get_instance_id(),

                'timecreated' => time() - random_int(HOURSECS, WEEKSECS) + (HOURSECS * $i),

            ]));

        }

        return $logs;

    }

}