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_forum;

use core_external\external_api;

use externallib_advanced_testcase;

use mod_forum_external;

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

global $CFG;

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

require_once($CFG->dirroot . '/mod/forum/lib.php');

/**

 * The module forums external functions unit tests

 *

 * @package    mod_forum

 * @category   external

 * @copyright  2012 Mark Nelson <markn@moodle.com>

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

 */

final class externallib_test extends externallib_advanced_testcase {

    /**

     * Tests set up

     */

    protected function setUp(): void {

        global $CFG;

        parent::setUp();

        // We must clear the subscription caches. This has to be done both before each test, and after in case of other

        // tests using these functions.

        \mod_forum\subscriptions::reset_forum_cache();

        require_once($CFG->dirroot . '/mod/forum/externallib.php');

    }

    public function tearDown(): void {

        // We must clear the subscription caches. This has to be done both before each test, and after in case of other

        // tests using these functions.

        \mod_forum\subscriptions::reset_forum_cache();

        parent::tearDown();

    }

    /**

     * Get the expected attachment.

     *

     * @param \stored_file $file

     * @param array $values

     * @param \moodle_url|null $url

     * @return array

     */

    protected function get_expected_attachment(\stored_file $file, array $values  = [], ?\moodle_url $url = null): array {

        if (!$url) {

            $url = \moodle_url::make_pluginfile_url(

                $file->get_contextid(),

                $file->get_component(),

                $file->get_filearea(),

                $file->get_itemid(),

                $file->get_filepath(),

                $file->get_filename()

            );

            $url->param('forcedownload', 1);

        }

        return array_merge(

            [

                'contextid' => $file->get_contextid(),

                'component' => $file->get_component(),

                'filearea' => $file->get_filearea(),

                'itemid' => $file->get_itemid(),

                'filepath' => $file->get_filepath(),

                'filename' => $file->get_filename(),

                'isdir' => $file->is_directory(),

                'isimage' => $file->is_valid_image(),

                'timemodified' => $file->get_timemodified(),

                'timecreated' => $file->get_timecreated(),

                'filesize' => $file->get_filesize(),

                'author' => $file->get_author(),

                'license' => $file->get_license(),

                'filenameshort' => $file->get_filename(),

                'filesizeformatted' => display_size((int) $file->get_filesize()),

                'icon' => $file->is_directory() ? file_folder_icon() : file_file_icon($file),

                'timecreatedformatted' => userdate($file->get_timecreated()),

                'timemodifiedformatted' => userdate($file->get_timemodified()),

                'url' => $url->out(),

            ], $values);

    }

    /**

     * Test get forums

     */

    public function test_mod_forum_get_forums_by_courses(): void {

        global $USER, $CFG, $DB;

        $this->resetAfterTest(true);

        // Create a user.

        $user = self::getDataGenerator()->create_user(array('trackforums' => 1));

        // Set to the user.

        self::setUser($user);

        // Create courses to add the modules.

        $course1 = self::getDataGenerator()->create_course();

        $course2 = self::getDataGenerator()->create_course();

        // First forum.

        $record = new \stdClass();

        $record->introformat = FORMAT_HTML;

        $record->course = $course1->id;

        $record->trackingtype = FORUM_TRACKING_FORCED;

        $forum1 = self::getDataGenerator()->create_module('forum', $record);

        // Second forum.

        $record = new \stdClass();

        $record->introformat = FORMAT_HTML;

        $record->course = $course2->id;

        $record->trackingtype = FORUM_TRACKING_OFF;

        $forum2 = self::getDataGenerator()->create_module('forum', $record);

        $forum2->introfiles = [];

        // Add discussions to the forums.

        $record = new \stdClass();

        $record->course = $course1->id;

        $record->userid = $user->id;

        $record->forum = $forum1->id;

        $discussion1 = self::getDataGenerator()->get_plugin_generator('mod_forum')->create_discussion($record);

        // Expect one discussion.

        $forum1->numdiscussions = 1;

        $forum1->cancreatediscussions = true;

        $forum1->istracked = true;

        $forum1->unreadpostscount = 0;

        $forum1->introfiles = [];

        $forum1->lang = '';

        $record = new \stdClass();

        $record->course = $course2->id;

        $record->userid = $user->id;

        $record->forum = $forum2->id;

        $discussion2 = self::getDataGenerator()->get_plugin_generator('mod_forum')->create_discussion($record);

        $discussion3 = self::getDataGenerator()->get_plugin_generator('mod_forum')->create_discussion($record);

        // Expect two discussions.

        $forum2->numdiscussions = 2;

        // Default limited role, no create discussion capability enabled.

        $forum2->cancreatediscussions = false;

        $forum2->istracked = false;

        $forum2->lang = '';

        // Check the forum was correctly created.

        $this->assertEquals(2, $DB->count_records_select('forum', 'id = :forum1 OR id = :forum2',

                array('forum1' => $forum1->id, 'forum2' => $forum2->id)));

        // Enrol the user in two courses.

        // DataGenerator->enrol_user automatically sets a role for the user with the permission mod/form:viewdiscussion.

        $this->getDataGenerator()->enrol_user($user->id, $course1->id, null, 'manual');

        // Execute real Moodle enrolment as we'll call unenrol() method on the instance later.

        $enrol = enrol_get_plugin('manual');

        $enrolinstances = enrol_get_instances($course2->id, true);

        foreach ($enrolinstances as $courseenrolinstance) {

            if ($courseenrolinstance->enrol == "manual") {

                $instance2 = $courseenrolinstance;

                break;

            }

        }

        $enrol->enrol_user($instance2, $user->id);

        // Assign capabilities to view forums for forum 2.

        $cm2 = get_coursemodule_from_id('forum', $forum2->cmid, 0, false, MUST_EXIST);

        $context2 = \context_module::instance($cm2->id);

        $newrole = create_role('Role 2', 'role2', 'Role 2 description');

        $roleid2 = $this->assignUserCapability('mod/forum:viewdiscussion', $context2->id, $newrole);

        // Create what we expect to be returned when querying the two courses.

        unset($forum1->displaywordcount);

        unset($forum2->displaywordcount);

        $expectedforums = array();

        $expectedforums[$forum1->id] = (array) $forum1;

        $expectedforums[$forum2->id] = (array) $forum2;

        // Call the external function passing course ids.

        $forums = mod_forum_external::get_forums_by_courses(array($course1->id, $course2->id));

        $forums = external_api::clean_returnvalue(mod_forum_external::get_forums_by_courses_returns(), $forums);

        $this->assertCount(2, $forums);

        foreach ($forums as $forum) {

            $this->assertEquals($expectedforums[$forum['id']], $forum);

        }

        // Call the external function without passing course id.

        $forums = mod_forum_external::get_forums_by_courses();

        $forums = external_api::clean_returnvalue(mod_forum_external::get_forums_by_courses_returns(), $forums);

        $this->assertCount(2, $forums);

        foreach ($forums as $forum) {

            $this->assertEquals($expectedforums[$forum['id']], $forum);

        }

        // Unenrol user from second course and alter expected forums.

        $enrol->unenrol_user($instance2, $user->id);

        unset($expectedforums[$forum2->id]);

        // Call the external function without passing course id.

        $forums = mod_forum_external::get_forums_by_courses();

        $forums = external_api::clean_returnvalue(mod_forum_external::get_forums_by_courses_returns(), $forums);

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

        $this->assertEquals($expectedforums[$forum1->id], $forums[0]);

        $this->assertTrue($forums[0]['cancreatediscussions']);

        // Change the type of the forum, the user shouldn't be able to add discussions.

        $DB->set_field('forum', 'type', 'news', array('id' => $forum1->id));

        $forums = mod_forum_external::get_forums_by_courses();

        $forums = external_api::clean_returnvalue(mod_forum_external::get_forums_by_courses_returns(), $forums);

        $this->assertFalse($forums[0]['cancreatediscussions']);

        // Call for the second course we unenrolled the user from.

        $forums = mod_forum_external::get_forums_by_courses(array($course2->id));

        $forums = external_api::clean_returnvalue(mod_forum_external::get_forums_by_courses_returns(), $forums);

        $this->assertCount(0, $forums);

    }

    /**

     * Test the toggle favourite state

     */

    public function test_mod_forum_toggle_favourite_state(): void {

        global $USER, $CFG, $DB;

        $this->resetAfterTest(true);

        // Create a user.

        $user = self::getDataGenerator()->create_user(array('trackforums' => 1));

        // Set to the user.

        self::setUser($user);

        // Create courses to add the modules.

        $course1 = self::getDataGenerator()->create_course();

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

        $record = new \stdClass();

        $record->introformat = FORMAT_HTML;

        $record->course = $course1->id;

        $record->trackingtype = FORUM_TRACKING_OFF;

        $forum1 = self::getDataGenerator()->create_module('forum', $record);

        $forum1->introfiles = [];

        // Add discussions to the forums.

        $record = new \stdClass();

        $record->course = $course1->id;

        $record->userid = $user->id;

        $record->forum = $forum1->id;

        $discussion1 = self::getDataGenerator()->get_plugin_generator('mod_forum')->create_discussion($record);

        $response = mod_forum_external::toggle_favourite_state($discussion1->id, 1);

        $response = external_api::clean_returnvalue(mod_forum_external::toggle_favourite_state_returns(), $response);

        $this->assertTrue($response['userstate']['favourited']);

        $response = mod_forum_external::toggle_favourite_state($discussion1->id, 0);

        $response = external_api::clean_returnvalue(mod_forum_external::toggle_favourite_state_returns(), $response);

        $this->assertFalse($response['userstate']['favourited']);

        $this->setUser(0);

        try {

            $response = mod_forum_external::toggle_favourite_state($discussion1->id, 0);

        } catch (\moodle_exception $e) {

            $this->assertEquals('requireloginerror', $e->errorcode);

        }

    }

    /**

     * Test the toggle pin state

     */

    public function test_mod_forum_set_pin_state(): void {

        $this->resetAfterTest(true);

        // Create a user.

        $user = self::getDataGenerator()->create_user(array('trackforums' => 1));

        // Set to the user.

        self::setUser($user);

        // Create courses to add the modules.

        $course1 = self::getDataGenerator()->create_course();

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

        $record = new \stdClass();

        $record->introformat = FORMAT_HTML;

        $record->course = $course1->id;

        $record->trackingtype = FORUM_TRACKING_OFF;

        $forum1 = self::getDataGenerator()->create_module('forum', $record);

        $forum1->introfiles = [];

        // Add discussions to the forums.

        $record = new \stdClass();

        $record->course = $course1->id;

        $record->userid = $user->id;

        $record->forum = $forum1->id;

        $discussion1 = self::getDataGenerator()->get_plugin_generator('mod_forum')->create_discussion($record);

        try {

            $response = mod_forum_external::set_pin_state($discussion1->id, 1);

        } catch (\Exception $e) {

            $this->assertEquals('cannotpindiscussions', $e->errorcode);

        }

        self::setAdminUser();

        $response = mod_forum_external::set_pin_state($discussion1->id, 1);

        $response = external_api::clean_returnvalue(mod_forum_external::set_pin_state_returns(), $response);

        $this->assertTrue($response['pinned']);

        $response = mod_forum_external::set_pin_state($discussion1->id, 0);

        $response = external_api::clean_returnvalue(mod_forum_external::set_pin_state_returns(), $response);

        $this->assertFalse($response['pinned']);

    }

    /**

     * Test get forum posts

     *

     * Tests is similar to the get_forum_discussion_posts only utilizing the new return structure and entities

     */

    public function test_mod_forum_get_discussion_posts(): void {

        global $CFG;

        $this->resetAfterTest(true);

        // Set the CFG variable to allow track forums.

        $CFG->forum_trackreadposts = true;

        $urlfactory = \mod_forum\local\container::get_url_factory();

        $legacyfactory = \mod_forum\local\container::get_legacy_data_mapper_factory();

        $entityfactory = \mod_forum\local\container::get_entity_factory();

        // Create course to add the module.

        $course1 = self::getDataGenerator()->create_course();

        // Create a user who can track forums.

        $record = new \stdClass();

        $record->trackforums = true;

        $user1 = self::getDataGenerator()->create_user($record);

        // Create a bunch of other users to post.

        $user2 = self::getDataGenerator()->create_user();

        $user2entity = $entityfactory->get_author_from_stdClass($user2);

        $exporteduser2 = [

            'id' => (int) $user2->id,

            'fullname' => fullname($user2),

            'isdeleted' => false,

            'groups' => [],

            'urls' => [

                'profile' => $urlfactory->get_author_profile_url($user2entity, $course1->id)->out(false),

                'profileimage' => $urlfactory->get_author_profile_image_url($user2entity),

            ]

        ];

        $user2->fullname = $exporteduser2['fullname'];

        $user3 = self::getDataGenerator()->create_user(['fullname' => "Mr Pants 1"]);

        $user3entity = $entityfactory->get_author_from_stdClass($user3);

        $exporteduser3 = [

            'id' => (int) $user3->id,

            'fullname' => fullname($user3),

            'groups' => [],

            'isdeleted' => false,

            'urls' => [

                'profile' => $urlfactory->get_author_profile_url($user3entity, $course1->id)->out(false),

                'profileimage' => $urlfactory->get_author_profile_image_url($user3entity),

            ]

        ];

        $user3->fullname = $exporteduser3['fullname'];

        $forumgenerator = self::getDataGenerator()->get_plugin_generator('mod_forum');

        // Set the first created user to the test user.

        self::setUser($user1);

        // Forum with tracking off.

        $record = new \stdClass();

        $record->course = $course1->id;

        $record->trackingtype = FORUM_TRACKING_OFF;

        // Display word count. Otherwise, word and char counts will be set to null by the forum post exporter.

        $record->displaywordcount = true;

        $forum1 = self::getDataGenerator()->create_module('forum', $record);

        $forum1context = \context_module::instance($forum1->cmid);

        // Forum with tracking enabled.

        $record = new \stdClass();

        $record->course = $course1->id;

        $forum2 = self::getDataGenerator()->create_module('forum', $record);

        $forum2cm = get_coursemodule_from_id('forum', $forum2->cmid);

        $forum2context = \context_module::instance($forum2->cmid);

        // Add discussions to the forums.

        $record = new \stdClass();

        $record->course = $course1->id;

        $record->userid = $user1->id;

        $record->forum = $forum1->id;

        $discussion1 = $forumgenerator->create_discussion($record);

        $record = new \stdClass();

        $record->course = $course1->id;

        $record->userid = $user2->id;

        $record->forum = $forum1->id;

        $discussion2 = $forumgenerator->create_discussion($record);

        $record = new \stdClass();

        $record->course = $course1->id;

        $record->userid = $user2->id;

        $record->forum = $forum2->id;

        $discussion3 = $forumgenerator->create_discussion($record);

        // Add 2 replies to the discussion 1 from different users.

        $record = new \stdClass();

        $record->discussion = $discussion1->id;

        $record->parent = $discussion1->firstpost;

        $record->userid = $user2->id;

        $discussion1reply1 = $forumgenerator->create_post($record);

        $filename = 'shouldbeanimage.jpg';

        // Add a fake inline image to the post.

        $filerecordinline = array(

            'contextid' => $forum1context->id,

            'component' => 'mod_forum',

            'filearea'  => 'post',

            'itemid'    => $discussion1reply1->id,

            'filepath'  => '/',

            'filename'  => $filename,

        );

        $fs = get_file_storage();

        $timepost = time();

        $file = $fs->create_file_from_string($filerecordinline, 'image contents (not really)');

        $record->parent = $discussion1reply1->id;

        $record->userid = $user3->id;

        $discussion1reply2 = $forumgenerator->create_post($record);

        // Enrol the user in the  course.

        $enrol = enrol_get_plugin('manual');

        // Following line enrol and assign default role id to the user.

        // So the user automatically gets mod/forum:viewdiscussion on all forums of the course.

        $this->getDataGenerator()->enrol_user($user1->id, $course1->id);

        $this->getDataGenerator()->enrol_user($user2->id, $course1->id);

        // Delete one user, to test that we still receive posts by this user.

        delete_user($user3);

        $exporteduser3 = [

            'id' => (int) $user3->id,

            'fullname' => get_string('deleteduser', 'mod_forum'),

            'groups' => [],

            'isdeleted' => true,

            'urls' => [

                'profile' => $urlfactory->get_author_profile_url($user3entity, $course1->id)->out(false),

                'profileimage' => $urlfactory->get_author_profile_image_url($user3entity),

            ]

        ];

        // Create what we expect to be returned when querying the discussion.

        $expectedposts = array(

            'posts' => array(),

            'courseid' => $course1->id,

            'forumid' => $forum1->id,

            'ratinginfo' => array(

                'contextid' => $forum1context->id,

                'component' => 'mod_forum',

                'ratingarea' => 'post',

                'canviewall' => null,

                'canviewany' => null,

                'scales' => array(),

                'ratings' => array(),

            ),

            'warnings' => array(),

        );

        // User pictures are initially empty, we should get the links once the external function is called.

        $isolatedurl = $urlfactory->get_discussion_view_url_from_discussion_id($discussion1reply2->discussion);

        $isolatedurl->params(['parent' => $discussion1reply2->id]);

        $message = file_rewrite_pluginfile_urls($discussion1reply2->message, 'pluginfile.php',

            $forum1context->id, 'mod_forum', 'post', $discussion1reply2->id);

        $expectedposts['posts'][] = array(

            'id' => $discussion1reply2->id,

            'discussionid' => $discussion1reply2->discussion,

            'parentid' => $discussion1reply2->parent,

            'hasparent' => true,

            'timecreated' => $discussion1reply2->created,

            'timemodified' => $discussion1reply2->modified,

            'subject' => $discussion1reply2->subject,

            'replysubject' => $discussion1reply2->subject,

            'message' => $message,

            'messageformat' => 1,   // This value is usually changed by \core_external\util::format_text() function.

            'unread' => null,

            'isdeleted' => false,

            'isprivatereply' => false,

            'haswordcount' => true,

            'wordcount' => count_words($message),

            'charcount' => count_letters($message),

            'author'=> $exporteduser3,

            'attachments' => [],

            'messageinlinefiles' => [],

            'tags' => [],

            'html' => [

                'rating' => null,

                'taglist' => null,

                'authorsubheading' => $forumgenerator->get_author_subheading_html((object)$exporteduser3, $discussion1reply2->created)

            ],

            'capabilities' => [

                'view' => 1,

                'edit' => 0,

                'delete' => 0,

                'split' => 0,

                'reply' => 1,

                'export' => 0,

                'controlreadstatus' => 0,

                'canreplyprivately' => 0,

                'selfenrol' => 0

            ],

            'urls' => [

                'view' => $urlfactory->get_view_post_url_from_post_id($discussion1reply2->discussion, $discussion1reply2->id),

                'viewisolated' => $isolatedurl->out(false),

                'viewparent' => $urlfactory->get_view_post_url_from_post_id($discussion1reply2->discussion, $discussion1reply2->parent),

                'edit' => null,

                'delete' =>null,

                'split' => null,

                'reply' => (new \moodle_url('/mod/forum/post.php#mformforum', [

                    'reply' => $discussion1reply2->id

                ]))->out(false),

                'export' => null,

                'markasread' => null,

                'markasunread' => null,

                'discuss' => $urlfactory->get_discussion_view_url_from_discussion_id($discussion1reply2->discussion),

            ],

        );

        $isolatedurl = $urlfactory->get_discussion_view_url_from_discussion_id($discussion1reply1->discussion);

        $isolatedurl->params(['parent' => $discussion1reply1->id]);

        $message = file_rewrite_pluginfile_urls($discussion1reply1->message, 'pluginfile.php',

            $forum1context->id, 'mod_forum', 'post', $discussion1reply1->id);

        $expectedposts['posts'][] = array(

            'id' => $discussion1reply1->id,

            'discussionid' => $discussion1reply1->discussion,

            'parentid' => $discussion1reply1->parent,

            'hasparent' => true,

            'timecreated' => $discussion1reply1->created,

            'timemodified' => $discussion1reply1->modified,

            'subject' => $discussion1reply1->subject,

            'replysubject' => $discussion1reply1->subject,

            'message' => $message,

            'messageformat' => 1,   // This value is usually changed by \core_external\util::format_text() function.

            'unread' => null,

            'isdeleted' => false,

            'isprivatereply' => false,

            'haswordcount' => true,

            'wordcount' => count_words($message),

            'charcount' => count_letters($message),

            'author'=> $exporteduser2,

            'attachments' => [],

            'messageinlinefiles' => [

            ],

            'tags' => [],

            'html' => [

                'rating' => null,

                'taglist' => null,

                'authorsubheading' => $forumgenerator->get_author_subheading_html((object)$exporteduser2, $discussion1reply1->created)

            ],

            'capabilities' => [

                'view' => 1,

                'edit' => 0,

                'delete' => 0,

                'split' => 0,

                'reply' => 1,

                'export' => 0,

                'controlreadstatus' => 0,

                'canreplyprivately' => 0,

                'selfenrol' => 0

            ],

            'urls' => [

                'view' => $urlfactory->get_view_post_url_from_post_id($discussion1reply1->discussion, $discussion1reply1->id),

                'viewisolated' => $isolatedurl->out(false),

                'viewparent' => $urlfactory->get_view_post_url_from_post_id($discussion1reply1->discussion, $discussion1reply1->parent),

                'edit' => null,

                'delete' =>null,

                'split' => null,

                'reply' => (new \moodle_url('/mod/forum/post.php#mformforum', [

                    'reply' => $discussion1reply1->id

                ]))->out(false),

                'export' => null,

                'markasread' => null,

                'markasunread' => null,

                'discuss' => $urlfactory->get_discussion_view_url_from_discussion_id($discussion1reply1->discussion),

            ],

        );

        // Test a discussion with two additional posts (total 3 posts).

        $posts = mod_forum_external::get_discussion_posts($discussion1->id, 'modified', 'DESC', true);

        $posts = external_api::clean_returnvalue(mod_forum_external::get_discussion_posts_returns(), $posts);

        $this->assertEquals(3, count($posts['posts']));

        // Unset the initial discussion post.

        array_pop($posts['posts']);

        $this->assertEquals($expectedposts, $posts);

        // Check we receive the unread count correctly on tracked forum.

        forum_tp_count_forum_unread_posts($forum2cm, $course1, true);    // Reset static cache.

        $result = mod_forum_external::get_forums_by_courses(array($course1->id));

        $result = external_api::clean_returnvalue(mod_forum_external::get_forums_by_courses_returns(), $result);

        foreach ($result as $f) {

            if ($f['id'] == $forum2->id) {

                $this->assertEquals(1, $f['unreadpostscount']);

            }

        }

        // Test discussion without additional posts. There should be only one post (the one created by the discussion).

        $posts = mod_forum_external::get_discussion_posts($discussion2->id, 'modified', 'DESC');

        $posts = external_api::clean_returnvalue(mod_forum_external::get_discussion_posts_returns(), $posts);

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

        // Test discussion tracking on not tracked forum.

        $result = mod_forum_external::view_forum_discussion($discussion1->id);

        $result = external_api::clean_returnvalue(mod_forum_external::view_forum_discussion_returns(), $result);

        $this->assertTrue($result['status']);

        $this->assertEmpty($result['warnings']);

        // Test posts have not been marked as read.

        $posts = mod_forum_external::get_discussion_posts($discussion1->id, 'modified', 'DESC');

        $posts = external_api::clean_returnvalue(mod_forum_external::get_discussion_posts_returns(), $posts);

        foreach ($posts['posts'] as $post) {

            $this->assertNull($post['unread']);

        }

        // Test discussion tracking on tracked forum.

        $result = mod_forum_external::view_forum_discussion($discussion3->id);

        $result = external_api::clean_returnvalue(mod_forum_external::view_forum_discussion_returns(), $result);

        $this->assertTrue($result['status']);

        $this->assertEmpty($result['warnings']);

        // Test posts have been marked as read.

        $posts = mod_forum_external::get_discussion_posts($discussion3->id, 'modified', 'DESC');

        $posts = external_api::clean_returnvalue(mod_forum_external::get_discussion_posts_returns(), $posts);

        foreach ($posts['posts'] as $post) {

            $this->assertFalse($post['unread']);

        }

        // Check we receive 0 unread posts.

        forum_tp_count_forum_unread_posts($forum2cm, $course1, true);    // Reset static cache.

        $result = mod_forum_external::get_forums_by_courses(array($course1->id));

        $result = external_api::clean_returnvalue(mod_forum_external::get_forums_by_courses_returns(), $result);

        foreach ($result as $f) {

            if ($f['id'] == $forum2->id) {

                $this->assertEquals(0, $f['unreadpostscount']);

            }

        }

    }

    /**

     * Test get forum posts

     */

    public function test_mod_forum_get_discussion_posts_deleted(): void {

        global $CFG, $PAGE;

        $this->resetAfterTest(true);

        $generator = self::getDataGenerator()->get_plugin_generator('mod_forum');

        // Create a course and enrol some users in it.

        $course1 = self::getDataGenerator()->create_course();

        // Create users.

        $user1 = self::getDataGenerator()->create_user();

        $this->getDataGenerator()->enrol_user($user1->id, $course1->id);

        $user2 = self::getDataGenerator()->create_user();

        $this->getDataGenerator()->enrol_user($user2->id, $course1->id);

        // Set the first created user to the test user.

        self::setUser($user1);

        // Create test data.

        $forum1 = self::getDataGenerator()->create_module('forum', (object) [

            'course' => $course1->id,

        ]);

        $forum1context = \context_module::instance($forum1->cmid);

        // Add discussions to the forum.

        $discussion = $generator->create_discussion((object) [

            'course' => $course1->id,

            'userid' => $user1->id,

            'forum' => $forum1->id,

        ]);

        $discussion2 = $generator->create_discussion((object) [

            'course' => $course1->id,

            'userid' => $user2->id,

            'forum' => $forum1->id,

        ]);

        // Add replies to the discussion.

        $discussionreply1 = $generator->create_post((object) [

            'discussion' => $discussion->id,

            'parent' => $discussion->firstpost,

            'userid' => $user2->id,

        ]);

        $discussionreply2 = $generator->create_post((object) [

            'discussion' => $discussion->id,

            'parent' => $discussionreply1->id,

            'userid' => $user2->id,

            'subject' => '',

            'message' => '',

            'messageformat' => FORMAT_PLAIN,

            'deleted' => 1,

        ]);

        $discussionreply3 = $generator->create_post((object) [

            'discussion' => $discussion->id,

            'parent' => $discussion->firstpost,

            'userid' => $user2->id,

        ]);

        // Test where some posts have been marked as deleted.

        $posts = mod_forum_external::get_discussion_posts($discussion->id, 'modified', 'DESC');

        $posts = external_api::clean_returnvalue(mod_forum_external::get_discussion_posts_returns(), $posts);

        $deletedsubject = get_string('forumsubjectdeleted', 'mod_forum');

        $deletedmessage = get_string('forumbodydeleted', 'mod_forum');

        foreach ($posts['posts'] as $post) {

            if ($post['id'] == $discussionreply2->id) {

                $this->assertTrue($post['isdeleted']);

                $this->assertEquals($deletedsubject, $post['subject']);

                $this->assertEquals($deletedmessage, $post['message']);

            } else {

                $this->assertFalse($post['isdeleted']);

                $this->assertNotEquals($deletedsubject, $post['subject']);

                $this->assertNotEquals($deletedmessage, $post['message']);

            }

        }

    }

    /**

     * Test get forum posts returns inline attachments.

     */

    public function test_mod_forum_get_discussion_posts_inline_attachments(): void {

        global $CFG;

        $this->resetAfterTest(true);

        // Create a course and enrol some users in it.

        $course = self::getDataGenerator()->create_course();

        // Create users.

        $user = self::getDataGenerator()->create_user();

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

        // Set the first created user to the test user.

        self::setUser($user);

        // Create test data.

        $forum = self::getDataGenerator()->create_module('forum', (object) [

            'course' => $course->id,

        ]);

        // Create a file in a draft area for inline attachments.

        $draftidinlineattach = file_get_unused_draft_itemid();

        $draftidattach = file_get_unused_draft_itemid();

        self::setUser($user);

        $usercontext = \context_user::instance($user->id);

        $filepath = '/';

        $filearea = 'draft';

        $component = 'user';

        $filenameimg = 'fakeimage.png';

        $filerecordinline = [

            'contextid' => $usercontext->id,

            'component' => $component,

            'filearea'  => $filearea,

            'itemid'    => $draftidinlineattach,

            'filepath'  => $filepath,

            'filename'  => $filenameimg,

        ];

        $fs = get_file_storage();

        $fs->create_file_from_string($filerecordinline, 'image contents (not really)');

        // Create discussion.

        $dummytext = 'Here is an inline image: <img src="' . $CFG->wwwroot .

            "/draftfile.php/{$usercontext->id}/user/draft/{$draftidinlineattach}/{$filenameimg}" .

            '" alt="inlineimage">.';

        $options = [

            [

                'name' => 'inlineattachmentsid',

                'value' => $draftidinlineattach

            ],

            [

                'name' => 'attachmentsid',

                'value' => $draftidattach

            ]

        ];

        $discussion = mod_forum_external::add_discussion($forum->id, 'the inline attachment subject', $dummytext,

            -1, $options);

        $posts = mod_forum_external::get_discussion_posts($discussion['discussionid'], 'modified', 'DESC');

        $posts = external_api::clean_returnvalue(mod_forum_external::get_discussion_posts_returns(), $posts);

        $post = $posts['posts'][0];

        $this->assertCount(0, $post['messageinlinefiles']);

        $this->assertEmpty($post['messageinlinefiles']);

        $posts = mod_forum_external::get_discussion_posts($discussion['discussionid'], 'modified', 'DESC',

            true);

        $posts = external_api::clean_returnvalue(mod_forum_external::get_discussion_posts_returns(), $posts);

        $post = $posts['posts'][0];

        $this->assertCount(1, $post['messageinlinefiles']);

        $this->assertEquals('fakeimage.png', $post['messageinlinefiles'][0]['filename']);

    }

    /**

     * Test get forum posts (qanda forum)

     */

    public function test_mod_forum_get_discussion_posts_qanda(): void {

        global $CFG, $DB;

        $this->resetAfterTest(true);

        $record = new \stdClass();

        $user1 = self::getDataGenerator()->create_user($record);

        $user2 = self::getDataGenerator()->create_user();

        // Set the first created user to the test user.

        self::setUser($user1);

        // Create course to add the module.

        $course1 = self::getDataGenerator()->create_course();

        $this->getDataGenerator()->enrol_user($user1->id, $course1->id);

        $this->getDataGenerator()->enrol_user($user2->id, $course1->id);

        // Forum with tracking off.

        $record = new \stdClass();

        $record->course = $course1->id;

        $record->type = 'qanda';

        $forum1 = self::getDataGenerator()->create_module('forum', $record);

        $forum1context = \context_module::instance($forum1->cmid);

        // Add discussions to the forums.

        $record = new \stdClass();

        $record->course = $course1->id;

        $record->userid = $user2->id;

        $record->forum = $forum1->id;

        $discussion1 = self::getDataGenerator()->get_plugin_generator('mod_forum')->create_discussion($record);

        // Add 1 reply (not the actual user).

        $record = new \stdClass();

        $record->discussion = $discussion1->id;

        $record->parent = $discussion1->firstpost;

        $record->userid = $user2->id;

        $discussion1reply1 = self::getDataGenerator()->get_plugin_generator('mod_forum')->create_post($record);

        // We still see only the original post.

        $posts = mod_forum_external::get_discussion_posts($discussion1->id, 'modified', 'DESC');

        $posts = external_api::clean_returnvalue(mod_forum_external::get_discussion_posts_returns(), $posts);

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

        // Add a new reply, the user is going to be able to see only the original post and their new post.

        $record = new \stdClass();

        $record->discussion = $discussion1->id;

        $record->parent = $discussion1->firstpost;

        $record->userid = $user1->id;

        $discussion1reply2 = self::getDataGenerator()->get_plugin_generator('mod_forum')->create_post($record);

        $posts = mod_forum_external::get_discussion_posts($discussion1->id, 'modified', 'DESC');

        $posts = external_api::clean_returnvalue(mod_forum_external::get_discussion_posts_returns(), $posts);

        $this->assertEquals(2, count($posts['posts']));

        // Now, we can fake the time of the user post, so he can se the rest of the discussion posts.

        $discussion1reply2->created -= $CFG->maxeditingtime * 2;

        $DB->update_record('forum_posts', $discussion1reply2);

        $posts = mod_forum_external::get_discussion_posts($discussion1->id, 'modified', 'DESC');

        $posts = external_api::clean_returnvalue(mod_forum_external::get_discussion_posts_returns(), $posts);

        $this->assertEquals(3, count($posts['posts']));

    }

    /**

     * Test get forum discussions

     */

    public function test_mod_forum_get_forum_discussions(): void {

        global $CFG, $DB, $PAGE;

        $this->resetAfterTest(true);

        // Set the CFG variable to allow track forums.

        $CFG->forum_trackreadposts = true;

        // Create a user who can track forums.

        $record = new \stdClass();

        $record->trackforums = true;

        $user1 = self::getDataGenerator()->create_user($record);

        // Create a bunch of other users to post.

        $user2 = self::getDataGenerator()->create_user();

        $user3 = self::getDataGenerator()->create_user();

        $user4 = self::getDataGenerator()->create_user();

        // Set the first created user to the test user.

        self::setUser($user1);

        // Create courses to add the modules.

        $course1 = self::getDataGenerator()->create_course();

        // First forum with tracking off.

        $record = new \stdClass();

        $record->course = $course1->id;

        $record->trackingtype = FORUM_TRACKING_OFF;

        $forum1 = self::getDataGenerator()->create_module('forum', $record);

        // Add discussions to the forums.

        $record = new \stdClass();

        $record->course = $course1->id;

        $record->userid = $user1->id;

        $record->forum = $forum1->id;

        $discussion1 = self::getDataGenerator()->get_plugin_generator('mod_forum')->create_discussion($record);

        // Add three replies to the discussion 1 from different users.

        $record = new \stdClass();

        $record->discussion = $discussion1->id;

        $record->parent = $discussion1->firstpost;

        $record->userid = $user2->id;

        $discussion1reply1 = self::getDataGenerator()->get_plugin_generator('mod_forum')->create_post($record);

        $record->parent = $discussion1reply1->id;

        $record->userid = $user3->id;

        $discussion1reply2 = self::getDataGenerator()->get_plugin_generator('mod_forum')->create_post($record);

        $record->userid = $user4->id;

        $discussion1reply3 = self::getDataGenerator()->get_plugin_generator('mod_forum')->create_post($record);

        // Enrol the user in the first course.

        $enrol = enrol_get_plugin('manual');

        // We don't use the dataGenerator as we need to get the $instance2 to unenrol later.

        $enrolinstances = enrol_get_instances($course1->id, true);

        foreach ($enrolinstances as $courseenrolinstance) {

            if ($courseenrolinstance->enrol == "manual") {

                $instance1 = $courseenrolinstance;

                break;

            }

        }

        $enrol->enrol_user($instance1, $user1->id);

        // Delete one user.

        delete_user($user4);

        // Assign capabilities to view discussions for forum 1.

        $cm = get_coursemodule_from_id('forum', $forum1->cmid, 0, false, MUST_EXIST);

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

        $newrole = create_role('Role 2', 'role2', 'Role 2 description');

        $this->assignUserCapability('mod/forum:viewdiscussion', $context->id, $newrole);

        // Create what we expect to be returned when querying the forums.

        $post1 = $DB->get_record('forum_posts', array('id' => $discussion1->firstpost), '*', MUST_EXIST);

        // User pictures are initially empty, we should get the links once the external function is called.

        $expecteddiscussions = array(

            'id' => $discussion1->firstpost,

            'name' => $discussion1->name,

            'groupid' => (int) $discussion1->groupid,

            'timemodified' => (int) $discussion1reply3->created,

            'usermodified' => (int) $discussion1reply3->userid,

            'timestart' => (int) $discussion1->timestart,

            'timeend' => (int) $discussion1->timeend,

            'discussion' => (int) $discussion1->id,

            'parent' => 0,

            'userid' => (int) $discussion1->userid,

            'created' => (int) $post1->created,

            'modified' => (int) $post1->modified,

            'mailed' => (int) $post1->mailed,

            'subject' => $post1->subject,

            'message' => $post1->message,

            'messageformat' => (int) $post1->messageformat,

            'messagetrust' => (int) $post1->messagetrust,

            'attachment' => $post1->attachment,

            'totalscore' => (int) $post1->totalscore,

            'mailnow' => (int) $post1->mailnow,

            'userfullname' => fullname($user1),

            'usermodifiedfullname' => fullname($user4),

            'userpictureurl' => '',

            'usermodifiedpictureurl' => '',

            'numreplies' => 3,

            'numunread' => 0,

            'pinned' => (bool) FORUM_DISCUSSION_UNPINNED,

            'locked' => false,

            'canreply' => false,

            'canlock' => false,

            'starred' => false,

            'canfavourite' => true

        );

        // Call the external function passing forum id.