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

namespace mod_bigbluebuttonbn\external;

use core_external\external_api;
use mod_bigbluebuttonbn\instance;
use mod_bigbluebuttonbn\test\testcase_helper_trait;
use require_login_exception;

defined('MOODLE_INTERNAL') || die();

global $CFG;
require_once($CFG->dirroot . '/webservice/tests/helpers.php');

/**
 * Tests for the update_course class.
 *
 * @package    mod_bigbluebuttonbn
 * @category   test
 * @copyright  2021 - present, Blindside Networks Inc
 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 * @author    Laurent David (laurent@call-learning.fr)
 * @covers \mod_bigbluebuttonbn\external\get_recordings
 */
class get_recordings_test extends \externallib_advanced_testcase {
    use testcase_helper_trait;

    /**
     * Setup for test
     */
    public function setUp(): void {
        parent::setUp();
        $this->initialise_mock_server();
    }

    /**
     * Helper
     *
     * @param mixed ...$params
     * @return array|bool|mixed
     */
    protected function get_recordings(...$params) {
        $recordings = get_recordings::execute(...$params);

        return external_api::clean_returnvalue(get_recordings::execute_returns(), $recordings);
    }

    /**
     * Test execute API CALL with no instance
     */
    public function test_execute_wrong_instance(): void {
        $this->resetAfterTest();
        $getrecordings = $this->get_recordings(1234);

        $this->assertIsArray($getrecordings);
        $this->assertArrayHasKey('status', $getrecordings);
        $this->assertEquals(false, $getrecordings['status']);
        $this->assertStringContainsString('nosuchinstance', $getrecordings['warnings'][0]['warningcode']);
    }

    /**
     * Test execute API CALL without login
     */
    public function test_execute_without_login(): void {
        $this->resetAfterTest();

        $course = $this->getDataGenerator()->create_course();
        $record = $this->getDataGenerator()->create_module('bigbluebuttonbn', ['course' => $course->id]);
        $instance = instance::get_from_instanceid($record->id);

        $this->expectException(require_login_exception::class);
        $this->get_recordings($instance->get_instance_id());
    }

    /**
     * Test execute API CALL with invalid login
     */
    public function test_execute_with_invalid_login(): void {
        $this->resetAfterTest();

        $generator = $this->getDataGenerator();
        $course = $generator->create_course();
        $record = $generator->create_module('bigbluebuttonbn', ['course' => $course->id]);
        $instance = instance::get_from_instanceid($record->id);

        $user = $generator->create_user();
        $this->setUser($user);

        $this->expectException(require_login_exception::class);
        $this->get_recordings($instance->get_instance_id());
    }

    /**
     * When login as a student
     */
    public function test_execute_with_valid_login(): void {
        $this->resetAfterTest();

        $generator = $this->getDataGenerator();
        $course = $generator->create_course();
        $record = $generator->create_module('bigbluebuttonbn', ['course' => $course->id]);
        $instance = instance::get_from_instanceid($record->id);

        $user = $generator->create_and_enrol($course, 'student');
        $this->setUser($user);

        $getrecordings = $this->get_recordings($instance->get_instance_id());

        $this->assertIsArray($getrecordings);
        $this->assertArrayHasKey('status', $getrecordings);
        $this->assertEquals(true, $getrecordings['status']);
        $this->assertNotEmpty($getrecordings['tabledata']);
        $this->assertEquals('[]', $getrecordings['tabledata']['data']);
    }

    /**
     * Check if tools are present for teacher/moderator
     */
    public function test_get_recordings_tools(): void {
        $this->resetAfterTest();
        $dataset = [
            'type' => instance::TYPE_ALL,
            'groups' => null,
            'users' => [['username' => 't1', 'role' => 'editingteacher'], ['username' => 's1', 'role' => 'student']],
            'recordingsdata' => [
                [['name' => 'Recording1']],
                [['name' => 'Recording2']]
            ],
        ];
        $activityid = $this->create_from_dataset($dataset);
        $instance = instance::get_from_instanceid($activityid);

        $context = \context_course::instance($instance->get_course_id());
        foreach ($dataset['users'] as $userdef) {
            $user = \core_user::get_user_by_username($userdef['username']);
            $this->setUser($user);
            $getrecordings = $this->get_recordings($instance->get_instance_id());
            // Check users see or do not see recording dependings on their groups.
            foreach ($dataset['recordingsdata'] as $recordingdata) {
                foreach ($recordingdata as $recording) {
                    if (has_capability('moodle/course:update', $context)) {
                        $this->assertStringContainsString('data-action=\"delete\"', $getrecordings['tabledata']['data'],
                            "User $user->username, should be able to delete the recording {$recording['name']}");
                        $this->assertStringContainsString('data-action=\"publish\"', $getrecordings['tabledata']['data'],
                            "User $user->username, should be able to publish the recording {$recording['name']}");
                    } else {
                        $this->assertStringNotContainsString('data-action=\"delete\"', $getrecordings['tabledata']['data'],
                            "User $user->username, should not be able to delete the recording {$recording['name']}");
                    }
                }
            }
        }
        // Now without delete.
        foreach ($dataset['users'] as $userdef) {
            $user = \core_user::get_user_by_username($userdef['username']);
            $this->setUser($user);
            $getrecordings = $this->get_recordings($instance->get_instance_id(), 'protect');
            // Check users see or do not see recording dependings on their groups.
            foreach ($dataset['recordingsdata'] as $recordingdata) {
                foreach ($recordingdata as $recording) {
                    $this->assertStringNotContainsString('data-action=\"delete\"', $getrecordings['tabledata']['data'],
                        "User $user->username, should not be able to delete the recording {$recording['name']}");
                }
            }
        }
    }

    /**
     * Check preview is present and displayed
     */
    public function test_get_recordings_preview(): void {
        $this->resetAfterTest();
        $dataset = [
            'type' => instance::TYPE_ALL,
            'additionalsettings' => [
                'recordings_preview' => 1
            ],
            'groups' => null,
            'users' => [['username' => 't1', 'role' => 'editingteacher'], ['username' => 's1', 'role' => 'student']],
            'recordingsdata' => [
                [['name' => 'Recording1']],
                [['name' => 'Recording2']]
            ],
        ];
        $activityid = $this->create_from_dataset($dataset);
        $instance = instance::get_from_instanceid($activityid);

        $context = \context_course::instance($instance->get_course_id());
        foreach ($dataset['users'] as $userdef) {
            $user = \core_user::get_user_by_username($userdef['username']);
            $this->setUser($user);
            $getrecordings = $this->get_recordings($instance->get_instance_id());
            $this->assertNotEmpty($getrecordings['tabledata']['columns']['3']);
            $this->assertEquals('preview', $getrecordings['tabledata']['columns']['3']['key']);
        }
    }

    /**
     * Check we can see all recording from a course in a room only instance
     * @covers \mod_bigbluebuttonbn\external\get_recordings::execute
     */
    public function test_get_recordings_room_only(): void {
        $this->resetAfterTest();
        set_config('bigbluebuttonbn_importrecordings_enabled', 1);
        $dataset = [
            'type' => instance::TYPE_ALL,
            'groups' => null,
            'users' => [['username' => 't1', 'role' => 'editingteacher'], ['username' => 's1', 'role' => 'student']],
            'recordingsdata' => [
                [['name' => 'Recording1']],
                [['name' => 'Recording2']]
            ],
        ];
        $activityid = $this->create_from_dataset($dataset);
        $instance = instance::get_from_instanceid($activityid);

        // Now create a recording only activity.
        $plugingenerator = $this->getDataGenerator()->get_plugin_generator('mod_bigbluebuttonbn');
        // Now create a new activity and import the first record.
        $newactivity = $plugingenerator->create_instance([
            'course' => $instance->get_course_id(),
            'type' => instance::TYPE_RECORDING_ONLY,
            'name' => 'Example 2'
        ]);
        $plugingenerator->create_meeting([
            'instanceid' => $newactivity->id,
        ]); // We need to have a meeting created in order to import recordings.
        $newinstance = instance::get_from_instanceid($newactivity->id);
        $this->create_recordings_for_instance($newinstance, [['name' => 'Recording3']]);

        foreach ($dataset['users'] as $userdef) {
            $user = \core_user::get_user_by_username($userdef['username']);
            $this->setUser($user);
            $getrecordings = $this->get_recordings($newinstance->get_instance_id());
            // Check users see or do not see recording dependings on their groups.
            $data = json_decode($getrecordings['tabledata']['data']);
            $this->assertCount(3, $data);
        }
    }

    /**
     * Check if we can see the imported recording in a new instance
     * @covers \mod_bigbluebuttonbn\external\get_recordings::execute
     */
    public function test_get_recordings_imported(): void {
        $this->resetAfterTest();
        set_config('bigbluebuttonbn_importrecordings_enabled', 1);
        $dataset = [
            'type' => instance::TYPE_ALL,
            'groups' => null,
            'users' => [['username' => 't1', 'role' => 'editingteacher'], ['username' => 's1', 'role' => 'student']],
            'recordingsdata' => [
                [['name' => 'Recording1']],
                [['name' => 'Recording2']]
            ],
        ];

        $activityid = $this->create_from_dataset($dataset);
        $instance = instance::get_from_instanceid($activityid);

        $plugingenerator = $this->getDataGenerator()->get_plugin_generator('mod_bigbluebuttonbn');
        // Now create a new activity and import the first record.
        $newactivity = $plugingenerator->create_instance([
            'course' => $instance->get_course_id(),
            'type' => instance::TYPE_ALL,
            'name' => 'Example 2'
        ]);
        $plugingenerator->create_meeting([
            'instanceid' => $newactivity->id,
        ]); // We need to have a meeting created in order to import recordings.
        $newinstance = instance::get_from_instanceid($newactivity->id);
        $recordings = $instance->get_recordings();
        foreach ($recordings as $recording) {
            if ($recording->get('name') == 'Recording1') {
                $recording->create_imported_recording($newinstance);
            }
        }

        foreach ($dataset['users'] as $userdef) {
            $user = \core_user::get_user_by_username($userdef['username']);
            $this->setUser($user);
            $getrecordings = $this->get_recordings($newinstance->get_instance_id());
            // Check users see or do not see recording dependings on their groups.
            foreach ($dataset['recordingsdata'] as $index => $recordingdata) {
                foreach ($recordingdata as $recording) {
                    if ($instance->can_manage_recordings()) {
                        $this->assertStringContainsString('data-action=\"delete\"', $getrecordings['tabledata']['data'],
                            "User $user->username, should be able to delete the recording {$recording['name']}");
                    } else {
                        $this->assertStringNotContainsString('data-action=\"delete\"', $getrecordings['tabledata']['data'],
                            "User $user->username, should not be able to delete the recording {$recording['name']}");
                    }
                    if ($index === 0) {
                        $this->assertStringContainsString($recording['name'], $getrecordings['tabledata']['data']);
                    } else {
                        $this->assertStringNotContainsString($recording['name'], $getrecordings['tabledata']['data']);
                    }
                }
            }

        }
    }

    /**
     * Check we can see only imported recordings in a recordings only instance when "Show only imported links" enabled.
     * @covers \mod_bigbluebuttonbn\external\get_recordings::execute
     */
    public function test_get_imported_recordings_only(): void {
        $this->resetAfterTest();
        set_config('bigbluebuttonbn_importrecordings_enabled', 1);
        $dataset = [
            'type' => instance::TYPE_ALL,
            'groups' => null,
            'users' => [['username' => 's1', 'role' => 'student']],
            'recordingsdata' => [
                [['name' => 'Recording1']],
                [['name' => 'Recording2']]
            ],
        ];
        $activityid = $this->create_from_dataset($dataset);
        $instance = instance::get_from_instanceid($activityid);

        // Now create a recording only activity.
        $plugingenerator = $this->getDataGenerator()->get_plugin_generator('mod_bigbluebuttonbn');
        // Now create a new activity and import the first record.
        $newactivity = $plugingenerator->create_instance([
            'course' => $instance->get_course_id(),
            'type' => instance::TYPE_RECORDING_ONLY,
            'name' => 'Example 2'
        ]);
        $plugingenerator->create_meeting([
            'instanceid' => $newactivity->id,
        ]); // We need to have a meeting created in order to import recordings.
        $newinstance = instance::get_from_instanceid($newactivity->id);
        $recordings = $instance->get_recordings();
        foreach ($recordings as $recording) {
            if ($recording->get('name') == 'Recording1') {
                $recording->create_imported_recording($newinstance);
            }
        }
        $user = \core_user::get_user_by_username('s1');
        $this->setUser($user);
        $getrecordings = $this->get_recordings($newinstance->get_instance_id());
        $data = json_decode($getrecordings['tabledata']['data']);
        // Check that all recordings including the imported recording appear.
        $this->assertCount(3, $data);
        // Set the flags to enable "Show only imported links".
        set_config('bigbluebuttonbn_recordings_imported_default', 1);
        set_config('bigbluebuttonbn_recordings_imported_editable', 0);
        $getrecordings = $this->get_recordings($newinstance->get_instance_id());
        $data = json_decode($getrecordings['tabledata']['data']);
        $this->assertCount(1, $data);
    }

    /**
     * Check if recording are visible/invisible depending on the group.
     *
     * @param string $type
     * @param array $groups
     * @param array $users
     * @param array $recordingsdata
     * @param array $test
     * @param int $coursemode
     *
     * @covers   \mod_bigbluebuttonbn\external\get_recordings::execute
     * @dataProvider recording_group_test_data
     */
    public function test_get_recordings_groups($type, $groups, $users, $recordingsdata, $test, $coursemode): void {
        $this->resetAfterTest();
        $dataset = compact('type', 'groups', 'users', 'recordingsdata', 'test', 'coursemode');
        $activityid = $this->create_from_dataset($dataset);
        $instance = instance::get_from_instanceid($activityid);

        foreach ($dataset['users'] as $userdef) {
            $user = \core_user::get_user_by_username($userdef['username']);
            $this->setUser($user);
            $groups = array_values(groups_get_my_groups());
            $mygroup = !empty($groups) ? end($groups) : null;

            $getrecordings = $this->get_recordings(
                $instance->get_instance_id(), null, !empty($mygroup) ? $mygroup->id : null);
            $allrecordingsnames = [];
            foreach ($recordingsdata as $groups => $rsinfo) {
                $rnames = array_map(function($rdata) {
                    return $rdata['name'];
                }, $rsinfo);
                $allrecordingsnames = array_merge($allrecordingsnames, $rnames);
            }
            // Check users see or do not see recording dependings on their groups.
            foreach ($dataset['test'][$user->username] as $viewablerecordings) {
                $viewablerecordings = $dataset['test'][$user->username];
                $invisiblerecordings = array_diff($allrecordingsnames, $viewablerecordings);
                foreach ($viewablerecordings as $viewablerecordingname) {
                    $this->assertStringContainsString($viewablerecordingname, $getrecordings['tabledata']['data'],
                        "User $user->username, should see recording {$viewablerecordingname}");
                }
                foreach ($invisiblerecordings as $invisiblerecordingname) {
                    $this->assertStringNotContainsString($invisiblerecordingname, $getrecordings['tabledata']['data'],
                        "User $user->username, should not see recording {$viewablerecordingname}");
                }
            }
        }
    }

    /**
     * Recording group test
     *
     * @return array[]
     */
    public function recording_group_test_data() {
        return [
            'visiblegroups' => [
                'type' => instance::TYPE_ALL,
                'groups' => ['G1' => ['s1'], 'G2' => ['s2']],
                'users' => [
                    ['username' => 't1', 'role' => 'editingteacher'],
                    ['username' => 's1', 'role' => 'student'],
                    ['username' => 's2', 'role' => 'student'],
                    ['username' => 's3', 'role' => 'student']
                ],
                'recordingsdata' => [
                    'G1' => [['name' => 'Recording1']],
                    'G2' => [['name' => 'Recording2']],
                    '' => [['name' => 'Recording3']]
                ],
                'test' => [
                    't1' => ['Recording1', 'Recording2', 'Recording3'], // A moderator should see all recordings.
                    's1' => ['Recording1'], // S1 can only see the recordings from his group.
                    's2' => ['Recording2'], // S2 can only see the recordings from his group.
                    's3' => ['Recording3', 'Recording2', 'Recording1']
                    // S3 should see recordings which have no groups and his groups's recording.
                ],
                'coursemode' => VISIBLEGROUPS
            ],
            'separategroups' => [
                'type' => instance::TYPE_ALL,
                'groups' => ['G1' => ['s1'], 'G2' => ['s2']],
                'users' => [
                    ['username' => 't1', 'role' => 'editingteacher'],
                    ['username' => 's1', 'role' => 'student'],
                    ['username' => 's2', 'role' => 'student']
                ],
                'recordingsdata' => [
                    'G1' => [['name' => 'Recording1']],
                    'G2' => [['name' => 'Recording2']],
                    '' => [['name' => 'Recording3']]
                ],
                'test' => [
                    't1' => ['Recording1', 'Recording2', 'Recording3'], // A moderator should see all recordings.
                    's1' => ['Recording1'], // S1 can only see the recordings from his group.
                    's2' => ['Recording2'], // S2 can only see the recordings from his group.
                    's3' => ['Recording3'] // S3 should see recordings which have no groups.
                ],
                'coursemode' => SEPARATEGROUPS
            ]
        ];
    }
}