Proyectos de Subversion Moodle

<?php

// This file is part of the Zoom plugin for 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 get_meeting_reports task class.

 *

 * @package    mod_zoom

 * @copyright  2019 UC Regents

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

 */

namespace mod_zoom;

use advanced_testcase;

use context_course;

use html_writer;

use moodle_url;

use stdClass;

/**

 * PHPunit testcase class.

 * @covers \mod_zoom\task\get_meeting_reports

 */

final class get_meeting_reports_test extends advanced_testcase {

    /**

     * Scheduled task object.

     * @var \mod_zoom\task\get_meeting_reports

     */

    private $meetingtask;

    /**

     * Fake data to return for mocked get_meeting_participants() call.

     * @var array

     */

    private $mockparticipantsdata;

    /**

     * Fake data from get_meeting_participants().

     * @var object

     */

    private $zoomdata;

    /**

     * Mocks the mod_zoom\webservice->get_meeting_participants() call, so we

     * don't actually call the real Zoom API.

     *

     * @param string $meetinguuid The meeting or webinar's UUID.

     * @param bool $webinar Whether the meeting or webinar whose information you want is a webinar.

     * @return array    The specified meeting participants array for given meetinguuid.

     */

    public function mock_get_meeting_participants($meetinguuid, $webinar) {

        return $this->mockparticipantsdata[$meetinguuid] ?? null;

    }

    /**

     * Setup.

     */

    public function setUp(): void {

        $this->resetAfterTest(true);

        $this->meetingtask = new \mod_zoom\task\get_meeting_reports();

        $data = [

            'id' => 'ARANDOMSTRINGFORUUID',

            'user_id' => 123456789,

            'name' => 'SMITH, JOE',

            'user_email' => 'joe@test.com',

            'join_time' => '2019-01-01T00:00:00Z',

            'leave_time' => '2019-01-01T00:01:00Z',

            'duration' => 60,

        ];

        $this->zoomdata = (object) $data;

    }

    /**

     * Make sure that format_participant() filters bad data from Zoom.

     */

    public function test_format_participant_filtering(): void {

        // Sometimes Zoom has a # instead of comma in the name.

        $this->zoomdata->name = 'SMITH# JOE';

        $participant = $this->meetingtask->format_participant($this->zoomdata, 1, [], []);

        $this->assertEquals('SMITH, JOE', $participant['name']);

    }

    /**

     * Make sure that format_participant() can match Moodle users.

     */

    public function test_format_participant_matching(): void {

        global $DB;

        return;

        // 1) If user does not match, verify that we are using data from Zoom.

        $participant = $this->meetingtask->format_participant($this->zoomdata, 1, [], []);

        $this->assertEquals($this->zoomdata->name, $participant['name']);

        $this->assertEquals($this->zoomdata->user_email, $participant['user_email']);

        $this->assertNull($participant['userid']);

        // 2) Try to match view via system email.

        // Add user's email to Moodle system.

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

            ['email' => $this->zoomdata->user_email]

        );

        $participant = $this->meetingtask->format_participant($this->zoomdata, 1, [], []);

        $this->assertEquals($user->id, $participant['userid']);

        $this->assertEquals(strtoupper(fullname($user)), $participant['name']);

        $this->assertEquals($user->email, $participant['user_email']);

        // 3) Try to match view via enrolled name.

        // Change user's name to make sure we are matching on name.

        $user->firstname = 'Firstname';

        $user->lastname = 'Lastname';

        $DB->update_record('user', $user);

        // Set to blank so previous test does not trigger.

        $this->zoomdata->user_email = '';

        // Create course and enroll user.

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

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

        [$names, $emails] = $this->meetingtask->get_enrollments($course->id);

        // Before Zoom data is changed, should return nothing.

        $participant = $this->meetingtask->format_participant($this->zoomdata, 1, $names, $emails);

        $this->assertNull($participant['userid']);

        // Change Zoom data and now user should be found.

        $this->zoomdata->name = strtoupper(fullname($user));

        $participant = $this->meetingtask->format_participant($this->zoomdata, 1, $names, $emails);

        $this->assertEquals($user->id, $participant['userid']);

        $this->assertEquals($names[$participant['userid']], $participant['name']);

        // Email should match what Zoom gives us.

        $this->assertEquals($this->zoomdata->user_email, $participant['user_email']);

        // 4) Try to match view via enrolled email.

        // Change user's email to make sure we are matching on email.

        $user->email = 'smith@test.com';

        $DB->update_record('user', $user);

        // Change name so previous test does not trigger.

        $this->zoomdata->name = 'Something Else';

        // Since email changed, update enrolled user data.

        [$names, $emails] = $this->meetingtask->get_enrollments($course->id);

        // Before Zoom data is changed, should return nothing.

        $participant = $this->meetingtask->format_participant($this->zoomdata, 1, $names, $emails);

        $this->assertNull($participant['userid']);

        // Change Zoom data and now user should be found.

        $this->zoomdata->user_email = $user->email;

        $participant = $this->meetingtask->format_participant($this->zoomdata, 1, $names, $emails);

        $this->assertEquals($user->id, $participant['userid']);

        $this->assertEquals($names[$participant['userid']], $participant['name']);

        // Email should match what Zoom gives us.

        $this->assertEquals($this->zoomdata->user_email, $participant['user_email']);

        // 5) Try to match user via id (uuid).

        // Insert previously generated $participant data, but with UUID set.

        $participant['uuid'] = $this->zoomdata->id;

        // Set userid to a given value so we know we got a match.

        $participant['userid'] = 999;

        $recordid = $DB->insert_record('zoom_meeting_participants', $participant);

        // Should return the found entry in zoom_meeting_participants.

        $newparticipant = $this->meetingtask->format_participant($this->zoomdata, 1, $names, $emails);

        $this->assertEquals($participant['uuid'], $newparticipant['uuid']);

        $this->assertEquals(999, $newparticipant['userid']);

        $this->assertEquals($participant['name'], $newparticipant['name']);

        // Email should match what Zoom gives us.

        $this->assertEquals($this->zoomdata->user_email, $newparticipant['user_email']);

    }

    /**

     * Make sure that format_participant() can match Moodle users more

     * aggressively on name.

     */

    public function test_format_participant_name_matching(): void {

        // Enroll a bunch of users. Note: names were generated by

        // https://www.behindthename.com/random/ and any similarity to anyone

        // real or ficitional is concidence and not intentional.

        $users[0] = $this->getDataGenerator()->create_user([

            'lastname' => 'VAN ANTWERPEN',

            'firstname' => 'LORETO ZAHIRA',

        ]);

        $users[1] = $this->getDataGenerator()->create_user([

            'lastname' => 'POWER',

            'firstname' => 'TEIMURAZI ELLI',

        ]);

        $users[2] = $this->getDataGenerator()->create_user([

            'lastname' => 'LITTLE',

            'firstname' => 'BASEMATH ALIZA',

        ]);

        $users[3] = $this->getDataGenerator()->create_user([

            'lastname' => 'MUTTON',

            'firstname' => 'RADOVAN BRIANNA',

        ]);

        $users[4] = $this->getDataGenerator()->create_user([

            'lastname' => 'MUTTON',

            'firstname' => 'BRUNO EVGENIJA',

        ]);

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

        foreach ($users as $user) {

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

        }

        [$names, $emails] = $this->meetingtask->get_enrollments($course->id);

        // 1) Make sure we match someone with middle name missing.

        $users[0]->firstname = 'LORETO';

        $this->zoomdata->name = fullname($users[0]);

        $participant = $this->meetingtask->format_participant($this->zoomdata, 1, $names, $emails);

        $this->assertEquals($users[0]->id, $participant['userid']);

        // 2) Make sure that name matches even if there are no spaces.

        $users[1]->firstname = str_replace(' ', '', $users[1]->firstname);

        $this->zoomdata->name = fullname($users[1]);

        $participant = $this->meetingtask->format_participant($this->zoomdata, 1, $names, $emails);

        $this->assertEquals($users[1]->id, $participant['userid']);

        // 3) Make sure that name matches even if we have different ordering.

        $this->zoomdata->name = 'MUTTON, RADOVAN BRIANNA';

        $participant = $this->meetingtask->format_participant($this->zoomdata, 1, $names, $emails);

        $this->assertEquals($users[3]->id, $participant['userid']);

        // 4) Make sure we do not match users if just last name is the same.

        $users[2]->firstname = 'JOSH';

        $this->zoomdata->name = fullname($users[2]);

        $participant = $this->meetingtask->format_participant($this->zoomdata, 1, $names, $emails);

        $this->assertEmpty($participant['userid']);

        // 5) Make sure we do not match users if name is not similar to anything.

        $users[4]->firstname = 'JOSH';

        $users[4]->lastname = 'SMITH';

        $this->zoomdata->name = fullname($users[4]);

        $participant = $this->meetingtask->format_participant($this->zoomdata, 1, $names, $emails);

        $this->assertEmpty($participant['userid']);

    }

    /**

     * Tests that we can handle when the Zoom API sometimes returns invalid

     * userids in the report/meeting/participants call.

     */

    public function test_invalid_userids(): void {

        global $DB, $SITE;

        // Make sure we start with nothing.

        $this->assertEquals(0, $DB->count_records('zoom_meeting_details'));

        $this->assertEquals(0, $DB->count_records('zoom_meeting_participants'));

        $this->mockparticipantsdata = [];

        // First mock the webservice object, so we can inject the return values

        // for get_meeting_participants.

        $mockwwebservice = $this->createMock('\mod_zoom\webservice');

        // What we want get_meeting_participants to return.

        $participant1 = new stdClass();

        // Sometimes Zoom returns timestamps appended to user_ids.

        $participant1->id = '';

        $participant1->user_id = '02020-04-01 15:02:01:040';

        $participant1->name = 'John Smith';

        $participant1->user_email = 'john@test.com';

        $participant1->join_time = '2020-04-01T15:02:01Z';

        $participant1->leave_time = '2020-04-01T15:02:01Z';

        $participant1->duration = 0;

        $this->mockparticipantsdata['someuuid'][] = $participant1;

        // Have another participant with normal data.

        $participant2 = new stdClass();

        $participant2->id = '';

        $participant2->user_id = 123;

        $participant2->name = 'Jane Smith';

        $participant2->user_email = 'jane@test.com';

        $participant2->join_time = '2020-04-01T15:00:00Z';

        $participant2->leave_time = '2020-04-01T15:10:00Z';

        $participant2->duration = 10;

        $this->mockparticipantsdata['someuuid'][] = $participant2;

        // Make get_meeting_participants() return our results array.

        $mockwwebservice->method('get_meeting_participants')

            ->will($this->returnCallback([$this, 'mock_get_meeting_participants']));

        $this->assertEquals(

            $this->mockparticipantsdata['someuuid'],

            $mockwwebservice->get_meeting_participants('someuuid', false)

        );

        // Now fake the meeting details.

        $meeting = new stdClass();

        $meeting->id = 12345;

        $meeting->topic = 'Some meeting';

        $meeting->start_time = '2020-04-01T15:00:00Z';

        $meeting->end_time = '2020-04-01T16:00:00Z';

        $meeting->uuid = 'someuuid';

        $meeting->duration = 60;

        $meeting->participants = 3;

        // Insert stub data for zoom table.

        $DB->insert_record('zoom', [

            'course' => $SITE->id,

            'meeting_id' => $meeting->id,

            'name' => 'Zoom',

            'exists_on_zoom' => ZOOM_MEETING_EXISTS,

        ]);

        // Run task process_meeting_reports() and should insert participants.

        $this->meetingtask->service = $mockwwebservice;

        $meeting = $this->meetingtask->normalize_meeting($meeting);

        $this->assertTrue($this->meetingtask->process_meeting_reports($meeting));

        // Make sure that only one details is added and two participants.

        $this->assertEquals(1, $DB->count_records('zoom_meeting_details'));

        $this->assertEquals(2, $DB->count_records('zoom_meeting_participants'));

        // Add in one more participant, make sure we update details and added

        // one more participant.

        $participant3 = new stdClass();

        $participant3->id = 'someuseruuid';

        $participant3->user_id = 234;

        $participant3->name = 'Joe Smith';

        $participant3->user_email = 'joe@test.com';

        $participant3->join_time = '2020-04-01T15:05:00Z';

        $participant3->leave_time = '2020-04-01T15:35:00Z';

        $participant3->duration = 30;

        $this->mockparticipantsdata['someuuid'][] = $participant3;

        $this->assertTrue($this->meetingtask->process_meeting_reports($meeting));

        $this->assertEquals(1, $DB->count_records('zoom_meeting_details'));

        $this->assertEquals(3, $DB->count_records('zoom_meeting_participants'));

    }

    /**

     * Tests that normalize_meeting() can handle different meeting records from

     * Dashboard API versus the Report API.

     */

    public function test_normalize_meeting(): void {

        $dashboardmeeting = [

            'uuid' => 'sfsdfsdfc6122222d',

            'id' => 1000000,

            'topic' => 'Awesome meeting',

            'host' => 'John Doe',

            'email' => 'test@email.com',

            'user_type' => 2,

            'start_time' => '2019-07-14T09:05:19.754Z',

            'end_time' => '2019-08-14T09:05:19.754Z',

            'duration' => '01:21:18',

            'participants' => 4,

            'has_pstn' => false,

            'has_voip' => false,

            'has_3rd_party_audio' => false,

            'has_video' => false,

            'has_screen_share' => false,

            'has_recording' => false,

            'has_sip' => false,

        ];

        $meeting = $this->meetingtask->normalize_meeting((object) $dashboardmeeting);

        $this->assertEquals($dashboardmeeting['uuid'], $meeting->uuid);

        $this->assertFalse(isset($meeting->id));

        $this->assertEquals($dashboardmeeting['id'], $meeting->meeting_id);

        $this->assertEquals($dashboardmeeting['topic'], $meeting->topic);

        $this->assertIsInt($meeting->start_time);

        $this->assertIsInt($meeting->end_time);

        $this->assertEquals($meeting->duration, 81);

        $this->assertEquals($dashboardmeeting['participants'], $meeting->participants_count);

        $this->assertNull($meeting->total_minutes);

        // Try duration under an hour.

        $dashboardmeeting['duration'] = '10:01';

        $meeting = $this->meetingtask->normalize_meeting((object) $dashboardmeeting);

        $this->assertEquals($meeting->duration, 10);

        $reportmeeting = [

            'uuid' => 'sfsdfsdfc6122222d',

            'id' => 1000000,

            'type' => 2,

            'topic' => 'Awesome meeting',

            'user_name' => 'John Doe',

            'user_email' => 'test@email.com',

            'start_time' => '2019-07-14T09:05:19.754Z',

            'end_time' => '2019-08-14T09:05:19.754Z',

            'duration' => 11,

            'total_minutes' => 11,

            'participants_count' => 4,

        ];

        $meeting = $this->meetingtask->normalize_meeting((object) $reportmeeting);

        $this->assertEquals($reportmeeting['uuid'], $meeting->uuid);

        $this->assertFalse(isset($meeting->id));

        $this->assertEquals($reportmeeting['id'], $meeting->meeting_id);

        $this->assertEquals($reportmeeting['topic'], $meeting->topic);

        $this->assertIsInt($meeting->start_time);

        $this->assertIsInt($meeting->end_time);

        $this->assertEquals($reportmeeting['participants_count'], $meeting->participants_count);

        $this->assertEquals($reportmeeting['total_minutes'], $meeting->total_minutes);

    }

    /**

     * Testing the grading method according to users duration in a meeting.

     * @return void

     */

    public function test_grading_method(): void {

        global $DB;

        $this->setAdminUser();

        // Make sure we start with nothing.

        // Deleting all records from previous tests.

        if ($DB->count_records('zoom_meeting_details') > 0) {

            $DB->delete_records('zoom_meeting_details');

        }

        if ($DB->count_records('zoom_meeting_participants') > 0) {

            $DB->delete_records('zoom_meeting_participants');

        }

        // Generate fake course.

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

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

        // Check that this teacher has the required capability to receive notification.

        $context = context_course::instance($course->id);

        $graders = get_users_by_capability($context, 'moodle/grade:edit');

        $this->assertEquals(1, count($graders));

        $firstkey = key($graders);

        $this->assertEquals($graders[$firstkey]->id, $teacher->id);

        // Now fake the meeting details.

        $meeting = new stdClass();

        $meeting->id = 456123;

        $meeting->topic = 'Some meeting';

        $meeting->start_time = '2020-04-01T15:00:00Z';

        $meeting->end_time = '2020-04-01T17:00:00Z';

        $meeting->uuid = 'someuuid123';

        $meeting->duration = 120; // In minutes.

        $meeting->participants = 4;

        // Create a new zoom instance.

        $params = [

            'course' => $course->id,

            'meeting_id' => $meeting->id,

            'grade' => 60,

            'name' => 'Zoom',

            'exists_on_zoom' => ZOOM_MEETING_EXISTS,

            'start_time' => strtotime('2020-04-01T15:00:00Z'),

            'duration' => 120 * 60, // In seconds.

        ];

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

        $instance = $generator->create_instance($params);

        $id = $instance->id;

        // Normalize the meeting.

        $meeting = $this->meetingtask->normalize_meeting($meeting);

        $meeting->zoomid = $id;

        $detailsid = $DB->insert_record('zoom_meeting_details', $meeting);

        $zoomrecord = $DB->get_record('zoom', ['id' => $id]);

        // Create users and corresponding meeting participants.

        $rawparticipants = [];

        $participants = [];

        // Enroll a bunch of users. Note: names were generated by

        // https://www.behindthename.com/random/ and any similarity to anyone

        // real or fictional is coincidence and not intentional.

        $users[0] = $this->getDataGenerator()->create_user([

            'lastname' => 'Arytis',

            'firstname' => 'Oitaa',

        ]);

        $users[1] = $this->getDataGenerator()->create_user([

            'lastname' => 'Chouxuong',

            'firstname' => 'Khah',

        ]);

        $users[2] = $this->getDataGenerator()->create_user([

            'lastname' => 'Spialdiouniem',

            'firstname' => 'Basem',

        ]);

        $users[3] = $this->getDataGenerator()->create_user([

            'lastname' => 'Padhzinnuj',

            'firstname' => 'Nibba',

        ]);

        $users[4] = $this->getDataGenerator()->create_user([

            'lastname' => 'Apea',

            'firstname' => 'Ziqit',

        ]);

        foreach ($users as $user) {

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

        }

        [$names, $emails] = $this->meetingtask->get_enrollments($course->id);

        // Create a participant with 5 min overlap.

        // Total time 35 min, total grade 17.5 .

        $rawparticipants[1] = (object) [

            'id' => 32132165,

            'user_id' => 4456,

            'name' => 'Oitaa Arytis',

            'user_email' => '',

            'join_time' => '2023-05-01T15:05:00Z',

            'leave_time' => '2023-05-01T15:35:00Z',

            'duration' => 30 * 60,

        ];

        $participants[1] = (object) $this->meetingtask->format_participant($rawparticipants[1], $detailsid, $names, $emails);

        $rawparticipants[2] = (object) [

            'id' => 32132165,

            'user_id' => 4456,

            'name' => 'Oitaa Arytis',

            'user_email' => '',

            'join_time' => '2023-05-01T15:30:00Z',

            'leave_time' => '2023-05-01T15:40:00Z',

            'duration' => 10 * 60,

        ];

        $participants[2] = (object) $this->meetingtask->format_participant($rawparticipants[2], $detailsid, $names, $emails);

        $overlap = $this->meetingtask->get_participant_overlap_time($participants[1], $participants[2]);

        $this->assertEquals(5 * 60, $overlap);

        // Also check for the same result if the data inverted.

        $overlap = $this->meetingtask->get_participant_overlap_time($participants[2], $participants[1]);

        $this->assertEquals(5 * 60, $overlap);

        // Create a participant with 30 min overlap.

        // Total duration 60 min. expect a mark of 30 .

        $rawparticipants[3] = (object) [

            'id' => '',

            'user_id' => 1234,

            'name' => 'Chouxuong Khah',

            'user_email' => '',

            'join_time' => '2023-05-01T15:00:00Z',

            'leave_time' => '2023-05-01T16:00:00Z',

            'duration' => 60 * 60,

        ];

        $participants[3] = (object) $this->meetingtask->format_participant($rawparticipants[3], $detailsid, $names, $emails);

        $rawparticipants[4] = (object) [

            'id' => '',

            'user_id' => 1234,

            'name' => 'Chouxuong Khah',

            'user_email' => '',

            'join_time' => '2023-05-01T15:30:00Z',

            'leave_time' => '2023-05-01T16:00:00Z',

            'duration' => 30 * 60,

        ];

        $participants[4] = (object) $this->meetingtask->format_participant($rawparticipants[4], $detailsid, $names, $emails);

        $overlap = $this->meetingtask->get_participant_overlap_time($participants[3], $participants[4]);

        $this->assertEquals(30 * 60, $overlap);

        // Also check for the same result if the data inverted.

        $overlap = $this->meetingtask->get_participant_overlap_time($participants[4], $participants[3]);

        $this->assertEquals(30 * 60, $overlap);

        // Another user with no overlaping.

        // Total duration 60 min. Expect mark 30 .

        $rawparticipants[5] = (object) [

            'id' => '',

            'user_id' => 564312,

            'name' => 'Spialdiouniem Basem',

            'user_email' => '',

            'join_time' => '2023-05-01T15:10:00Z',

            'leave_time' => '2023-05-01T16:00:00Z',

            'duration' => 50 * 60,

        ];

        $participants[5] = (object) $this->meetingtask->format_participant($rawparticipants[5], $detailsid, $names, $emails);

        $rawparticipants[6] = (object) [

            'id' => '',

            'user_id' => 564312,

            'name' => 'Spialdiouniem Basem',

            'user_email' => '',

            'join_time' => '2023-05-01T16:30:00Z',

            'leave_time' => '2023-05-01T16:40:00Z',

            'duration' => 10 * 60,

        ];

        $participants[6] = (object) $this->meetingtask->format_participant($rawparticipants[6], $detailsid, $names, $emails);

        $overlap = $this->meetingtask->get_participant_overlap_time($participants[5], $participants[6]);

        $this->assertEquals(0, $overlap);

        // Also check for the same result if the data inverted.

        $overlap = $this->meetingtask->get_participant_overlap_time($participants[6], $participants[5]);

        $this->assertEquals(0, $overlap);

        // Adding another participant.

        // Total duration 90 min, expect mark 45 .

        $rawparticipants[7] = (object) [

            'id' => '',

            'user_id' => 789453,

            'name' => 'Padhzinnuj Nibba',

            'user_email' => '',

            'join_time' => '2023-05-01T15:30:00Z',

            'leave_time' => '2023-05-01T17:00:00Z',

            'duration' => 90 * 60,

        ];

        // Adding a participant at which matching names will fail.

        // His duration is 110 min, this grant him a grade of 55.

        $rawparticipants[8] = (object) [

            'id' => '',

            'user_id' => 168452,

            'name' => 'Farouk',

            'user_email' => '',

            'join_time' => '2023-05-01T15:10:00Z',

            'leave_time' => '2023-05-01T17:00:00Z',

            'duration' => 110 * 60,

        ];

        $this->mockparticipantsdata['someuuid123'] = $rawparticipants;

        // First mock the webservice object, so we can inject the return values

        // for get_meeting_participants.

        $mockwwebservice = $this->createMock('\mod_zoom\webservice');

        $this->meetingtask->service = $mockwwebservice;

        // Make get_meeting_participants() return our results array.

        $mockwwebservice->method('get_meeting_participants')

            ->will($this->returnCallback([$this, 'mock_get_meeting_participants']));

        $this->assertEquals(

            $this->mockparticipantsdata['someuuid123'],

            $mockwwebservice->get_meeting_participants('someuuid123', false)

        );

        // Now let's test the grades.

        $DB->set_field('zoom', 'grading_method', 'period', ['id' => $zoomrecord->id]);

        // Prepare messages.

        $this->preventResetByRollback(); // Messaging does not like transactions...

        $sink = $this->redirectMessages();

        // Process meeting reports should call the function grading_participant_upon_duration

        // and insert grades.

        $this->assertTrue($this->meetingtask->process_meeting_reports($meeting));

        $this->assertEquals(1, $DB->count_records('zoom_meeting_details'));

        $this->assertEquals(8, $DB->count_records('zoom_meeting_participants'));

        $usersids = [];

        foreach ($users as $user) {

            $usersids[] = $user->id;

        }

        // Get the gradelist for all users created.

        $gradelist = grade_get_grades($course->id, 'mod', 'zoom', $zoomrecord->id, $usersids);

        $gradelistitems = $gradelist->items;

        $grades = $gradelistitems[0]->grades;

        // Check grades of first user.

        $grade = $grades[$users[0]->id]->grade;

        $this->assertEquals(17.5, $grade);

        // Check grades of second user.

        $grade = $grades[$users[1]->id]->grade;

        $this->assertEquals(30, $grade);

        // Check grades of third user.

        $grade = $grades[$users[2]->id]->grade;

        $this->assertEquals(30, $grade);

        // Check grades for fourth user.

        $grade = $grades[$users[3]->id]->grade;

        $this->assertEquals(45, $grade);

        // This user didn't enter the meeting.

        $grade = $grades[$users[4]->id]->grade;

        $this->assertEquals(null, $grade);

        // Let's check the teacher notification if it is ok?

        $messages = $sink->get_messages();

        // Only one teacher, means only one message.

        $this->assertEquals(1, count($messages));

        // Verify that it has been sent to the teacher.

        $this->assertEquals($teacher->id, $messages[0]->useridto);

        // Check the content of the message.

        // Grading item url.

        $gurl = new moodle_url(

            '/grade/report/singleview/index.php',

            [

                'id' => $course->id,

                'item' => 'grade',

                'itemid' => $gradelistitems[0]->id,

            ]

        );

        $gradeurl = html_writer::link($gurl, get_string('gradinglink', 'mod_zoom'));

        // Zoom instance url.

        $zurl = new moodle_url('/mod/zoom/view.php', ['id' => $id]);

        $zoomurl = html_writer::link($zurl, $zoomrecord->name);

        // The user need grading.

        $needgradestr = get_string('grading_needgrade', 'mod_zoom');

        $needgrade[] = '(Name: Farouk, grade: 55)';

        $needgrade = $needgradestr . implode('<br>', $needgrade) . "\n";

        $a = (object) [

            'name' => $zoomrecord->name,

            'graded' => 4,

            'alreadygraded' => 0,

            'needgrade' => $needgrade,

            'number' => 1,

            'gradeurl' => $gradeurl,

            'zoomurl' => $zoomurl,

            'notfound' => '',

            'notenrolled' => '',

        ];

        $messagecontent = get_string('gradingmessagebody', 'mod_zoom', $a);

        $this->assertStringContainsString($messagecontent, $messages[0]->fullmessage);

        // Redo the process again to be sure that no grades have been changed.

        $this->assertTrue($this->meetingtask->process_meeting_reports($meeting));

        $this->assertEquals(1, $DB->count_records('zoom_meeting_details'));

        $this->assertEquals(8, $DB->count_records('zoom_meeting_participants'));

        $gradelist = grade_get_grades($course->id, 'mod', 'zoom', $zoomrecord->id, $usersids);

        $gradelistitems = $gradelist->items;

        $grades = $gradelistitems[0]->grades;

        // Check grade for first user.

        $grade = $grades[$users[0]->id]->grade;

        $this->assertEquals(17.5, $grade);

        // Check grade for second user.

        $grade = $grades[$users[1]->id]->grade;

        $this->assertEquals(30, $grade);

        // Check grade for third user.

        $grade = $grades[$users[2]->id]->grade;

        $this->assertEquals(30, $grade);

        // Check grade for fourth user.

        $grade = $grades[$users[3]->id]->grade;

        $this->assertEquals(45, $grade);

        // This user didn't enter the meeting.

        $grade = $grades[$users[4]->id]->grade;

        $this->assertEquals(null, $grade);

        // Let's check if the teacher notification is ok.

        $messages = $sink->get_messages();

        // No new messages as there has not been an update for participants.

        $this->assertEquals(1, count($messages));

    }

}