mod/glossary/tests/lib_test.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /**
  18  * Glossary lib tests.
  19  *
  20  * @package    mod_glossary
  21  * @copyright  2015 Frédéric Massart - FMCorz.net
  22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23  */
  24 namespace mod_glossary;
  25
  26 defined('MOODLE_INTERNAL') || die();
  27
  28 global $CFG;
  29 require_once($CFG->dirroot . '/mod/glossary/lib.php');
  30 require_once($CFG->dirroot . '/mod/glossary/locallib.php');
  31
  32 /**
  33  * Glossary lib testcase.
  34  *
  35  * @package    mod_glossary
  36  * @copyright  2015 Frédéric Massart - FMCorz.net
  37  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  38  */
  39 class lib_test extends \advanced_testcase {
  40
  41     public function test_glossary_view() {
  42         global $CFG;
  43         $origcompletion = $CFG->enablecompletion;
  44         $CFG->enablecompletion = true;
  45         $this->resetAfterTest(true);
  46
  47         // Generate all the things.
  48         $c1 = $this->getDataGenerator()->create_course(array('enablecompletion' => 1));
  49         $g1 = $this->getDataGenerator()->create_module('glossary', array(
  50             'course' => $c1->id,
  51             'completion' => COMPLETION_TRACKING_AUTOMATIC,
  52             'completionview' => 1
  53         ));
  54         $g2 = $this->getDataGenerator()->create_module('glossary', array(
  55             'course' => $c1->id,
  56             'completion' => COMPLETION_TRACKING_AUTOMATIC,
  57             'completionview' => 1
  58         ));
  59         $u1 = $this->getDataGenerator()->create_user();
  60         $this->getDataGenerator()->enrol_user($u1->id, $c1->id);
  61         $modinfo = \course_modinfo::instance($c1->id);
  62         $cm1 = $modinfo->get_cm($g1->cmid);
  63         $cm2 = $modinfo->get_cm($g2->cmid);
  64         $ctx1 = $cm1->context;
  65         $completion = new \completion_info($c1);
  66
  67         $this->setUser($u1);
  68
  69         // Confirm what we've set up.
  70         $this->assertEquals(COMPLETION_NOT_VIEWED, $completion->get_data($cm1, false, $u1->id)->viewed);
  71         $this->assertEquals(COMPLETION_INCOMPLETE, $completion->get_data($cm1, false, $u1->id)->completionstate);
  72         $this->assertEquals(COMPLETION_NOT_VIEWED, $completion->get_data($cm2, false, $u1->id)->viewed);
  73         $this->assertEquals(COMPLETION_INCOMPLETE, $completion->get_data($cm2, false, $u1->id)->completionstate);
  74
  75         // Simulate the view call.
  76         $sink = $this->redirectEvents();
  77         glossary_view($g1, $c1, $cm1, $ctx1, 'letter');
  78         $events = $sink->get_events();
  79
  80         // Assertions.
  81         $this->assertCount(3, $events);
  82         $this->assertEquals('\core\event\course_module_completion_updated', $events[0]->eventname);
  83         $this->assertEquals('\core\event\course_module_completion_updated', $events[1]->eventname);
  84         $this->assertEquals('\mod_glossary\event\course_module_viewed', $events[2]->eventname);
  85         $this->assertEquals($g1->id, $events[2]->objectid);
  86         $this->assertEquals('letter', $events[2]->other['mode']);
  87         $this->assertEquals(COMPLETION_VIEWED, $completion->get_data($cm1, false, $u1->id)->viewed);
  88         $this->assertEquals(COMPLETION_COMPLETE, $completion->get_data($cm1, false, $u1->id)->completionstate);
  89         $this->assertEquals(COMPLETION_NOT_VIEWED, $completion->get_data($cm2, false, $u1->id)->viewed);
  90         $this->assertEquals(COMPLETION_INCOMPLETE, $completion->get_data($cm2, false, $u1->id)->completionstate);
  91
  92         // Tear down.
  93         $sink->close();
  94         $CFG->enablecompletion = $origcompletion;
  95     }
  96
  97     public function test_glossary_entry_view() {
  98         $this->resetAfterTest(true);
  99
 100         // Generate all the things.
 101         $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 102         $c1 = $this->getDataGenerator()->create_course();
 103         $g1 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 104         $e1 = $gg->create_content($g1);
 105         $u1 = $this->getDataGenerator()->create_user();
 106         $ctx = \context_module::instance($g1->cmid);
 107         $this->getDataGenerator()->enrol_user($u1->id, $c1->id);
 108
 109         // Assertions.
 110         $sink = $this->redirectEvents();
 111         glossary_entry_view($e1, $ctx);
 112         $events = $sink->get_events();
 113         $this->assertCount(1, $events);
 114         $this->assertEquals('\mod_glossary\event\entry_viewed', $events[0]->eventname);
 115         $this->assertEquals($e1->id, $events[0]->objectid);
 116         $sink->close();
 117     }
 118
 119     public function test_glossary_core_calendar_provide_event_action() {
 120         $this->resetAfterTest();
 121         $this->setAdminUser();
 122
 123         // Create the activity.
 124         $course = $this->getDataGenerator()->create_course();
 125         $glossary = $this->getDataGenerator()->create_module('glossary', array('course' => $course->id));
 126
 127         // Create a calendar event.
 128         $event = $this->create_action_event($course->id, $glossary->id,
 129             \core_completion\api::COMPLETION_EVENT_TYPE_DATE_COMPLETION_EXPECTED);
 130
 131         // Create an action factory.
 132         $factory = new \core_calendar\action_factory();
 133
 134         // Decorate action event.
 135         $actionevent = mod_glossary_core_calendar_provide_event_action($event, $factory);
 136
 137         // Confirm the event was decorated.
 138         $this->assertInstanceOf('\core_calendar\local\event\value_objects\action', $actionevent);
 139         $this->assertEquals(get_string('view'), $actionevent->get_name());
 140         $this->assertInstanceOf('moodle_url', $actionevent->get_url());
 141         $this->assertEquals(1, $actionevent->get_item_count());
 142         $this->assertTrue($actionevent->is_actionable());
 143     }
 144
 145     public function test_glossary_core_calendar_provide_event_action_as_non_user() {
 146         global $CFG;
 147
 148         $this->resetAfterTest();
 149         $this->setAdminUser();
 150
 151         // Create the activity.
 152         $course = $this->getDataGenerator()->create_course();
 153         $glossary = $this->getDataGenerator()->create_module('glossary', array('course' => $course->id));
 154
 155         // Create a calendar event.
 156         $event = $this->create_action_event($course->id, $glossary->id,
 157                 \core_completion\api::COMPLETION_EVENT_TYPE_DATE_COMPLETION_EXPECTED);
 158
 159         // Now log out.
 160         $CFG->forcelogin = true; // We don't want to be logged in as guest, as guest users might still have some capabilities.
 161         $this->setUser();
 162
 163         // Create an action factory.
 164         $factory = new \core_calendar\action_factory();
 165
 166         // Decorate action event for the student.
 167         $actionevent = mod_glossary_core_calendar_provide_event_action($event, $factory);
 168
 169         // Confirm the event is not shown at all.
 170         $this->assertNull($actionevent);
 171     }
 172
 173     public function test_glossary_core_calendar_provide_event_action_for_user() {
 174         global $CFG;
 175
 176         $this->resetAfterTest();
 177         $this->setAdminUser();
 178
 179         // Create a course.
 180         $course = $this->getDataGenerator()->create_course();
 181
 182         // Create a student.
 183         $student = $this->getDataGenerator()->create_and_enrol($course, 'student');
 184
 185         // Create the activity.
 186         $glossary = $this->getDataGenerator()->create_module('glossary', array('course' => $course->id));
 187
 188         // Create a calendar event.
 189         $event = $this->create_action_event($course->id, $glossary->id,
 190                 \core_completion\api::COMPLETION_EVENT_TYPE_DATE_COMPLETION_EXPECTED);
 191
 192         // Now log out.
 193         $CFG->forcelogin = true; // We don't want to be logged in as guest, as guest users might still have some capabilities.
 194         $this->setUser();
 195
 196         // Create an action factory.
 197         $factory = new \core_calendar\action_factory();
 198
 199         // Decorate action event for the student.
 200         $actionevent = mod_glossary_core_calendar_provide_event_action($event, $factory, $student->id);
 201
 202         // Confirm the event was decorated.
 203         $this->assertInstanceOf('\core_calendar\local\event\value_objects\action', $actionevent);
 204         $this->assertEquals(get_string('view'), $actionevent->get_name());
 205         $this->assertInstanceOf('moodle_url', $actionevent->get_url());
 206         $this->assertEquals(1, $actionevent->get_item_count());
 207         $this->assertTrue($actionevent->is_actionable());
 208     }
 209
 210     public function test_glossary_core_calendar_provide_event_action_in_hidden_section() {
 211         $this->resetAfterTest();
 212         $this->setAdminUser();
 213
 214         // Create a course.
 215         $course = $this->getDataGenerator()->create_course();
 216
 217         // Create a student.
 218         $student = $this->getDataGenerator()->create_and_enrol($course, 'student');
 219
 220         // Create the activity.
 221         $glossary = $this->getDataGenerator()->create_module('glossary', array('course' => $course->id));
 222
 223         // Create a calendar event.
 224         $event = $this->create_action_event($course->id, $glossary->id,
 225                 \core_completion\api::COMPLETION_EVENT_TYPE_DATE_COMPLETION_EXPECTED);
 226
 227         // Set sections 0 as hidden.
 228         set_section_visible($course->id, 0, 0);
 229
 230         // Create an action factory.
 231         $factory = new \core_calendar\action_factory();
 232
 233         // Decorate action event for the student.
 234         $actionevent = mod_glossary_core_calendar_provide_event_action($event, $factory, $student->id);
 235
 236         // Confirm the event is not shown at all.
 237         $this->assertNull($actionevent);
 238     }
 239
 240     public function test_glossary_core_calendar_provide_event_action_already_completed() {
 241         global $CFG;
 242
 243         $this->resetAfterTest();
 244         $this->setAdminUser();
 245
 246         $CFG->enablecompletion = 1;
 247
 248         // Create the activity.
 249         $course = $this->getDataGenerator()->create_course(array('enablecompletion' => 1));
 250         $glossary = $this->getDataGenerator()->create_module('glossary', array('course' => $course->id),
 251             array('completion' => 2, 'completionview' => 1, 'completionexpected' => time() + DAYSECS));
 252
 253         // Get some additional data.
 254         $cm = get_coursemodule_from_instance('glossary', $glossary->id);
 255
 256         // Create a calendar event.
 257         $event = $this->create_action_event($course->id, $glossary->id,
 258             \core_completion\api::COMPLETION_EVENT_TYPE_DATE_COMPLETION_EXPECTED);
 259
 260         // Mark the activity as completed.
 261         $completion = new \completion_info($course);
 262         $completion->set_module_viewed($cm);
 263
 264         // Create an action factory.
 265         $factory = new \core_calendar\action_factory();
 266
 267         // Decorate action event.
 268         $actionevent = mod_glossary_core_calendar_provide_event_action($event, $factory);
 269
 270         // Ensure result was null.
 271         $this->assertNull($actionevent);
 272     }
 273
 274     public function test_glossary_core_calendar_provide_event_action_already_completed_for_user() {
 275         global $CFG;
 276
 277         $this->resetAfterTest();
 278         $this->setAdminUser();
 279
 280         $CFG->enablecompletion = 1;
 281
 282         // Create a course.
 283         $course = $this->getDataGenerator()->create_course(array('enablecompletion' => 1));
 284
 285         // Create a student.
 286         $student = $this->getDataGenerator()->create_and_enrol($course, 'student');
 287
 288         // Create the activity.
 289         $glossary = $this->getDataGenerator()->create_module('glossary', array('course' => $course->id),
 290                 array('completion' => 2, 'completionview' => 1, 'completionexpected' => time() + DAYSECS));
 291
 292         // Get some additional data.
 293         $cm = get_coursemodule_from_instance('glossary', $glossary->id);
 294
 295         // Create a calendar event.
 296         $event = $this->create_action_event($course->id, $glossary->id,
 297                 \core_completion\api::COMPLETION_EVENT_TYPE_DATE_COMPLETION_EXPECTED);
 298
 299         // Mark the activity as completed for the user.
 300         $completion = new \completion_info($course);
 301         $completion->set_module_viewed($cm, $student->id);
 302
 303         // Create an action factory.
 304         $factory = new \core_calendar\action_factory();
 305
 306         // Decorate action event.
 307         $actionevent = mod_glossary_core_calendar_provide_event_action($event, $factory, $student->id);
 308
 309         // Ensure result was null.
 310         $this->assertNull($actionevent);
 311     }
 312
 313     /**
 314      * Creates an action event.
 315      *
 316      * @param int $courseid The course id.
 317      * @param int $instanceid The instance id.
 318      * @param string $eventtype The event type.
 319      * @return bool|calendar_event
 320      */
 321     private function create_action_event($courseid, $instanceid, $eventtype) {
 322         $event = new \stdClass();
 323         $event->name = 'Calendar event';
 324         $event->modulename  = 'glossary';
 325         $event->courseid = $courseid;
 326         $event->instance = $instanceid;
 327         $event->type = CALENDAR_EVENT_TYPE_ACTION;
 328         $event->eventtype = $eventtype;
 329         $event->timestart = time();
 330
 331         return \calendar_event::create($event);
 332     }
 333
 334     /**
 335      * Test the callback responsible for returning the completion rule descriptions.
 336      * This function should work given either an instance of the module (cm_info), such as when checking the active rules,
 337      * or if passed a stdClass of similar structure, such as when checking the the default completion settings for a mod type.
 338      */
 339     public function test_mod_glossary_completion_get_active_rule_descriptions() {
 340         $this->resetAfterTest();
 341         $this->setAdminUser();
 342
 343         // Two activities, both with automatic completion. One has the 'completionsubmit' rule, one doesn't.
 344         $course = $this->getDataGenerator()->create_course(['enablecompletion' => 2]);
 345         $glossary1 = $this->getDataGenerator()->create_module('glossary', [
 346             'course' => $course->id,
 347             'completion' => 2,
 348             'completionentries' => 3
 349         ]);
 350         $glossary2 = $this->getDataGenerator()->create_module('glossary', [
 351             'course' => $course->id,
 352             'completion' => 2,
 353             'completionentries' => 0
 354         ]);
 355         $cm1 = \cm_info::create(get_coursemodule_from_instance('glossary', $glossary1->id));
 356         $cm2 = \cm_info::create(get_coursemodule_from_instance('glossary', $glossary2->id));
 357
 358         // Data for the stdClass input type.
 359         // This type of input would occur when checking the default completion rules for an activity type, where we don't have
 360         // any access to cm_info, rather the input is a stdClass containing completion and customdata attributes, just like cm_info.
 361         $moddefaults = new \stdClass();
 362         $moddefaults->customdata = ['customcompletionrules' => ['completionentries' => 3]];
 363         $moddefaults->completion = 2;
 364
 365         $activeruledescriptions = [get_string('completionentriesdesc', 'glossary', $glossary1->completionentries)];
 366         $this->assertEquals(mod_glossary_get_completion_active_rule_descriptions($cm1), $activeruledescriptions);
 367         $this->assertEquals(mod_glossary_get_completion_active_rule_descriptions($cm2), []);
 368         $this->assertEquals(mod_glossary_get_completion_active_rule_descriptions($moddefaults), $activeruledescriptions);
 369         $this->assertEquals(mod_glossary_get_completion_active_rule_descriptions(new \stdClass()), []);
 370     }
 371
 372     public function test_mod_glossary_get_tagged_entries() {
 373         global $DB;
 374
 375         $this->resetAfterTest();
 376         $this->setAdminUser();
 377
 378         // Setup test data.
 379         $glossarygenerator = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 380         $course3 = $this->getDataGenerator()->create_course();
 381         $course2 = $this->getDataGenerator()->create_course();
 382         $course1 = $this->getDataGenerator()->create_course();
 383
 384         // Create and enrol a student.
 385         $student = self::getDataGenerator()->create_user();
 386         $studentrole = $DB->get_record('role', array('shortname' => 'student'));
 387         $this->getDataGenerator()->enrol_user($student->id, $course1->id, $studentrole->id, 'manual');
 388         $this->getDataGenerator()->enrol_user($student->id, $course2->id, $studentrole->id, 'manual');
 389
 390         // Create glossaries and entries.
 391         $glossary1 = $this->getDataGenerator()->create_module('glossary', array('course' => $course1->id));
 392         $glossary2 = $this->getDataGenerator()->create_module('glossary', array('course' => $course2->id));
 393         $glossary3 = $this->getDataGenerator()->create_module('glossary', array('course' => $course3->id));
 394         $entry11 = $glossarygenerator->create_content($glossary1, array('tags' => array('Cats', 'Dogs')));
 395         $entry12 = $glossarygenerator->create_content($glossary1, array('tags' => array('Cats', 'mice')));
 396         $entry13 = $glossarygenerator->create_content($glossary1, array('tags' => array('Cats')));
 397         $entry14 = $glossarygenerator->create_content($glossary1);
 398         $entry15 = $glossarygenerator->create_content($glossary1, array('tags' => array('Cats')));
 399         $entry16 = $glossarygenerator->create_content($glossary1, array('tags' => array('Cats'), 'approved' => false));
 400         $entry17 = $glossarygenerator->create_content($glossary1, array('tags' => array('Cats'), 'approved' => false, 'userid' => $student->id));
 401         $entry21 = $glossarygenerator->create_content($glossary2, array('tags' => array('Cats')));
 402         $entry22 = $glossarygenerator->create_content($glossary2, array('tags' => array('Cats', 'Dogs')));
 403         $entry23 = $glossarygenerator->create_content($glossary2, array('tags' => array('mice', 'Cats')));
 404         $entry31 = $glossarygenerator->create_content($glossary3, array('tags' => array('mice', 'Cats')));
 405
 406         $tag = \core_tag_tag::get_by_name(0, 'Cats');
 407
 408         // Admin can see everything.
 409         // Get first page of tagged entries (first 5 entries).
 410         $res = mod_glossary_get_tagged_entries($tag, /*$exclusivemode = */false,
 411             /*$fromctx = */0, /*$ctx = */0, /*$rec = */1, /*$entry = */0);
 412         $this->assertMatchesRegularExpression('/'.$entry11->concept.'</', $res->content);
 413         $this->assertMatchesRegularExpression('/'.$entry12->concept.'</', $res->content);
 414         $this->assertMatchesRegularExpression('/'.$entry13->concept.'</', $res->content);
 415         $this->assertDoesNotMatchRegularExpression('/'.$entry14->concept.'</', $res->content);
 416         $this->assertMatchesRegularExpression('/'.$entry15->concept.'</', $res->content);
 417         $this->assertMatchesRegularExpression('/'.$entry16->concept.'</', $res->content);
 418         $this->assertDoesNotMatchRegularExpression('/'.$entry17->concept.'</', $res->content);
 419         $this->assertDoesNotMatchRegularExpression('/'.$entry21->concept.'</', $res->content);
 420         $this->assertDoesNotMatchRegularExpression('/'.$entry22->concept.'</', $res->content);
 421         $this->assertDoesNotMatchRegularExpression('/'.$entry23->concept.'</', $res->content);
 422         $this->assertDoesNotMatchRegularExpression('/'.$entry31->concept.'</', $res->content);
 423         $this->assertEmpty($res->prevpageurl);
 424         $this->assertNotEmpty($res->nextpageurl);
 425         // Get second page of tagged entries (second 5 entries).
 426         $res = mod_glossary_get_tagged_entries($tag, /*$exclusivemode = */false,
 427             /*$fromctx = */0, /*$ctx = */0, /*$rec = */1, /*$entry = */1);
 428         $this->assertDoesNotMatchRegularExpression('/'.$entry11->concept.'</', $res->content);
 429         $this->assertDoesNotMatchRegularExpression('/'.$entry12->concept.'</', $res->content);
 430         $this->assertDoesNotMatchRegularExpression('/'.$entry13->concept.'</', $res->content);
 431         $this->assertDoesNotMatchRegularExpression('/'.$entry14->concept.'</', $res->content);
 432         $this->assertDoesNotMatchRegularExpression('/'.$entry15->concept.'</', $res->content);
 433         $this->assertDoesNotMatchRegularExpression('/'.$entry16->concept.'</', $res->content);
 434         $this->assertMatchesRegularExpression('/'.$entry17->concept.'</', $res->content);
 435         $this->assertMatchesRegularExpression('/'.$entry21->concept.'</', $res->content);
 436         $this->assertMatchesRegularExpression('/'.$entry22->concept.'</', $res->content);
 437         $this->assertMatchesRegularExpression('/'.$entry23->concept.'</', $res->content);
 438         $this->assertMatchesRegularExpression('/'.$entry31->concept.'</', $res->content);
 439         $this->assertNotEmpty($res->prevpageurl);
 440         $this->assertEmpty($res->nextpageurl);
 441
 442         $this->setUser($student);
 443         \core_tag_index_builder::reset_caches();
 444
 445         // User can not see entries in course 3 because he is not enrolled.
 446         $res = mod_glossary_get_tagged_entries($tag, /*$exclusivemode = */false,
 447             /*$fromctx = */0, /*$ctx = */0, /*$rec = */1, /*$entry = */1);
 448         $this->assertMatchesRegularExpression('/'.$entry22->concept.'/', $res->content);
 449         $this->assertMatchesRegularExpression('/'.$entry23->concept.'/', $res->content);
 450         $this->assertDoesNotMatchRegularExpression('/'.$entry31->concept.'/', $res->content);
 451
 452         // User can search glossary entries inside a course.
 453         $coursecontext = \context_course::instance($course1->id);
 454         $res = mod_glossary_get_tagged_entries($tag, /*$exclusivemode = */false,
 455             /*$fromctx = */0, /*$ctx = */$coursecontext->id, /*$rec = */1, /*$entry = */0);
 456         $this->assertMatchesRegularExpression('/'.$entry11->concept.'/', $res->content);
 457         $this->assertMatchesRegularExpression('/'.$entry12->concept.'/', $res->content);
 458         $this->assertMatchesRegularExpression('/'.$entry13->concept.'/', $res->content);
 459         $this->assertDoesNotMatchRegularExpression('/'.$entry14->concept.'/', $res->content);
 460         $this->assertMatchesRegularExpression('/'.$entry15->concept.'/', $res->content);
 461         $this->assertDoesNotMatchRegularExpression('/'.$entry21->concept.'/', $res->content);
 462         $this->assertDoesNotMatchRegularExpression('/'.$entry22->concept.'/', $res->content);
 463         $this->assertDoesNotMatchRegularExpression('/'.$entry23->concept.'/', $res->content);
 464         $this->assertEmpty($res->nextpageurl);
 465
 466         // User cannot see unapproved entries unless he is an author.
 467         $this->assertDoesNotMatchRegularExpression('/'.$entry16->concept.'/', $res->content);
 468         $this->assertMatchesRegularExpression('/'.$entry17->concept.'/', $res->content);
 469     }
 470
 471     public function test_glossary_get_entries_search() {
 472         $this->resetAfterTest();
 473         $this->setAdminUser();
 474         // Turn on glossary autolinking (usedynalink).
 475         set_config('glossary_linkentries', 1);
 476         $glossarygenerator = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 477         $course = $this->getDataGenerator()->create_course();
 478         $glossary = $this->getDataGenerator()->create_module('glossary', array('course' => $course->id));
 479         // Note this entry is not case sensitive by default (casesensitive = 0).
 480         $entry = $glossarygenerator->create_content($glossary);
 481         // Check that a search for the concept return the entry.
 482         $concept = $entry->concept;
 483         $search = glossary_get_entries_search($concept, $course->id);
 484         $this->assertCount(1, $search);
 485         $foundentry = array_shift($search);
 486         $this->assertEquals($foundentry->concept, $entry->concept);
 487         // Now try the same search but with a lowercase term.
 488         $concept = strtolower($entry->concept);
 489         $search = glossary_get_entries_search($concept, $course->id);
 490         $this->assertCount(1, $search);
 491         $foundentry = array_shift($search);
 492         $this->assertEquals($foundentry->concept, $entry->concept);
 493
 494         // Make an entry that is case sensitive (casesensitive = 1).
 495         set_config('glossary_casesensitive', 1);
 496         $entry = $glossarygenerator->create_content($glossary);
 497         $concept = $entry->concept;
 498         $search = glossary_get_entries_search($concept, $course->id);
 499         $this->assertCount(1, $search);
 500         $foundentry = array_shift($search);
 501         $this->assertEquals($foundentry->concept, $entry->concept);
 502         // Now try the same search but with a lowercase term.
 503         $concept = strtolower($entry->concept);
 504         $search = glossary_get_entries_search($concept, $course->id);
 505         $this->assertCount(0, $search);
 506     }
 507
 508     public function test_mod_glossary_can_delete_entry_users() {
 509         $this->resetAfterTest();
 510
 511         // Create required data.
 512         $course = $this->getDataGenerator()->create_course();
 513         $student = $this->getDataGenerator()->create_and_enrol($course, 'student');
 514         $anotherstudent = $this->getDataGenerator()->create_and_enrol($course, 'student');
 515         $teacher = $this->getDataGenerator()->create_and_enrol($course, 'editingteacher');
 516         $glossary = $this->getDataGenerator()->create_module('glossary', ['course' => $course->id]);
 517
 518         $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 519         $this->setUser($student);
 520         $entry = $gg->create_content($glossary);
 521         $context = \context_module::instance($glossary->cmid);
 522
 523         // Test student can delete.
 524         $this->assertTrue(mod_glossary_can_delete_entry($entry, $glossary, $context));
 525
 526         // Test teacher can delete.
 527         $this->setUser($teacher);
 528         $this->assertTrue(mod_glossary_can_delete_entry($entry, $glossary, $context));
 529
 530         // Test admin can delete.
 531         $this->setAdminUser();
 532         $this->assertTrue(mod_glossary_can_delete_entry($entry, $glossary, $context));
 533
 534         // Test a different student is not able to delete.
 535         $this->setUser($anotherstudent);
 536         $this->assertFalse(mod_glossary_can_delete_entry($entry, $glossary, $context));
 537
 538         // Test exception.
 539         $this->expectExceptionMessage(get_string('nopermissiontodelentry', 'error'));
 540         mod_glossary_can_delete_entry($entry, $glossary, $context, false);
 541     }
 542
 543     public function test_mod_glossary_can_delete_entry_edit_period() {
 544         global $CFG;
 545         $this->resetAfterTest();
 546
 547         // Create required data.
 548         $course = $this->getDataGenerator()->create_course();
 549         $student = $this->getDataGenerator()->create_and_enrol($course, 'student');
 550         $glossary = $this->getDataGenerator()->create_module('glossary', ['course' => $course->id, 'editalways' => 1]);
 551
 552         $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 553         $this->setUser($student);
 554         $entry = $gg->create_content($glossary);
 555         $context = \context_module::instance($glossary->cmid);
 556
 557         // Test student can always delete when edit always is set to 1.
 558         $entry->timecreated = time() - 2 * $CFG->maxeditingtime;
 559         $this->assertTrue(mod_glossary_can_delete_entry($entry, $glossary, $context));
 560
 561         // Test student cannot delete old entries when edit always is set to 0.
 562         $glossary->editalways = 0;
 563         $this->assertFalse(mod_glossary_can_delete_entry($entry, $glossary, $context));
 564
 565         // Test student can delete recent entries when edit always is set to 0.
 566         $entry->timecreated = time();
 567         $this->assertTrue(mod_glossary_can_delete_entry($entry, $glossary, $context));
 568
 569         // Check exception.
 570         $entry->timecreated = time() - 2 * $CFG->maxeditingtime;
 571         $this->expectExceptionMessage(get_string('errdeltimeexpired', 'glossary'));
 572         mod_glossary_can_delete_entry($entry, $glossary, $context, false);
 573     }
 574
 575     public function test_mod_glossary_delete_entry() {
 576         global $DB, $CFG;
 577         $this->resetAfterTest();
 578         require_once($CFG->dirroot . '/rating/lib.php');
 579
 580         // Create required data.
 581         $course = $this->getDataGenerator()->create_course();
 582         $student1 = $this->getDataGenerator()->create_and_enrol($course, 'student');
 583         $student2 = $this->getDataGenerator()->create_and_enrol($course, 'student');
 584
 585         $record = new \stdClass();
 586         $record->course = $course->id;
 587         $record->assessed = RATING_AGGREGATE_AVERAGE;
 588         $scale = $this->getDataGenerator()->create_scale(['scale' => 'A,B,C,D']);
 589         $record->scale = "-$scale->id";
 590         $glossary = $this->getDataGenerator()->create_module('glossary', $record);
 591         $context = \context_module::instance($glossary->cmid);
 592         $cm = get_coursemodule_from_instance('glossary', $glossary->id);
 593
 594         $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 595         $this->setUser($student1);
 596
 597         // Create entry with tags and rating.
 598         $entry = $gg->create_content(
 599             $glossary,
 600             ['approved' => 1, 'userid' => $student1->id, 'tags' => ['Cats', 'Dogs']],
 601             ['alias1', 'alias2']
 602         );
 603
 604         // Rate the entry as user2.
 605         $rating1 = new \stdClass();
 606         $rating1->contextid = $context->id;
 607         $rating1->component = 'mod_glossary';
 608         $rating1->ratingarea = 'entry';
 609         $rating1->itemid = $entry->id;
 610         $rating1->rating = 1; // 1 is A.
 611         $rating1->scaleid = "-$scale->id";
 612         $rating1->userid = $student2->id;
 613         $rating1->timecreated = time();
 614         $rating1->timemodified = time();
 615         $rating1->id = $DB->insert_record('rating', $rating1);
 616
 617         $sink = $this->redirectEvents();
 618         mod_glossary_delete_entry(fullclone($entry), $glossary, $cm, $context, $course);
 619         $events = $sink->get_events();
 620         $event = array_pop($events);
 621
 622         // Check events.
 623         $this->assertEquals('\mod_glossary\event\entry_deleted', $event->eventname);
 624         $this->assertEquals($entry->id, $event->objectid);
 625         $sink->close();
 626
 627         // No entry, no alias, no ratings, no tags.
 628         $this->assertEquals(0, $DB->count_records('glossary_entries', ['id' => $entry->id]));
 629         $this->assertEquals(0, $DB->count_records('glossary_alias', ['entryid' => $entry->id]));
 630         $this->assertEquals(0, $DB->count_records('rating', ['component' => 'mod_glossary', 'itemid' => $entry->id]));
 631         $this->assertEmpty(\core_tag_tag::get_by_name(0, 'Cats'));
 632     }
 633
 634     public function test_mod_glossary_delete_entry_imported() {
 635         global $DB;
 636         $this->resetAfterTest();
 637
 638         // Create required data.
 639         $course = $this->getDataGenerator()->create_course();
 640         $student = $this->getDataGenerator()->create_and_enrol($course, 'student');
 641
 642         $glossary1 = $this->getDataGenerator()->create_module('glossary', ['course' => $course->id]);
 643         $glossary2 = $this->getDataGenerator()->create_module('glossary', ['course' => $course->id]);
 644
 645         $context = \context_module::instance($glossary2->cmid);
 646         $cm = get_coursemodule_from_instance('glossary', $glossary2->id);
 647
 648         $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 649         $this->setUser($student);
 650
 651         $entry1 = $gg->create_content($glossary1);
 652         $entry2 = $gg->create_content(
 653             $glossary2,
 654             ['approved' => 1, 'userid' => $student->id, 'sourceglossaryid' => $glossary1->id, 'tags' => ['Cats', 'Dogs']]
 655         );
 656
 657         $sink = $this->redirectEvents();
 658         mod_glossary_delete_entry(fullclone($entry2), $glossary2, $cm, $context, $course);
 659         $events = $sink->get_events();
 660         $event = array_pop($events);
 661
 662         // Check events.
 663         $this->assertEquals('\mod_glossary\event\entry_deleted', $event->eventname);
 664         $this->assertEquals($entry2->id, $event->objectid);
 665         $sink->close();
 666
 667         // Check source.
 668         $this->assertEquals(0, $DB->get_field('glossary_entries', 'sourceglossaryid', ['id' => $entry2->id]));
 669         $this->assertEquals($glossary1->id, $DB->get_field('glossary_entries', 'glossaryid', ['id' => $entry2->id]));
 670
 671         // Tags.
 672         $this->assertEmpty(\core_tag_tag::get_by_name(0, 'Cats'));
 673     }
 674
 675     public function test_mod_glossary_can_update_entry_users() {
 676         $this->resetAfterTest();
 677
 678         // Create required data.
 679         $course = $this->getDataGenerator()->create_course();
 680         $student = $this->getDataGenerator()->create_and_enrol($course, 'student');
 681         $anotherstudent = $this->getDataGenerator()->create_and_enrol($course, 'student');
 682         $teacher = $this->getDataGenerator()->create_and_enrol($course, 'editingteacher');
 683         $glossary = $this->getDataGenerator()->create_module('glossary', array('course' => $course->id));
 684
 685         $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 686         $this->setUser($student);
 687         $entry = $gg->create_content($glossary);
 688         $context = \context_module::instance($glossary->cmid);
 689         $cm = get_coursemodule_from_instance('glossary', $glossary->id);
 690
 691         // Test student can update.
 692         $this->assertTrue(mod_glossary_can_update_entry($entry, $glossary, $context, $cm));
 693
 694         // Test teacher can update.
 695         $this->setUser($teacher);
 696         $this->assertTrue(mod_glossary_can_update_entry($entry, $glossary, $context, $cm));
 697
 698         // Test admin can update.
 699         $this->setAdminUser();
 700         $this->assertTrue(mod_glossary_can_update_entry($entry, $glossary, $context, $cm));
 701
 702         // Test a different student is not able to update.
 703         $this->setUser($anotherstudent);
 704         $this->assertFalse(mod_glossary_can_update_entry($entry, $glossary, $context, $cm));
 705
 706         // Test exception.
 707         $this->expectExceptionMessage(get_string('errcannoteditothers', 'glossary'));
 708         mod_glossary_can_update_entry($entry, $glossary, $context, $cm, false);
 709     }
 710
 711     public function test_mod_glossary_can_update_entry_edit_period() {
 712         global $CFG;
 713         $this->resetAfterTest();
 714
 715         // Create required data.
 716         $course = $this->getDataGenerator()->create_course();
 717         $student = $this->getDataGenerator()->create_and_enrol($course, 'student');
 718         $glossary = $this->getDataGenerator()->create_module('glossary', array('course' => $course->id, 'editalways' => 1));
 719
 720         $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 721         $this->setUser($student);
 722         $entry = $gg->create_content($glossary);
 723         $context = \context_module::instance($glossary->cmid);
 724         $cm = get_coursemodule_from_instance('glossary', $glossary->id);
 725
 726         // Test student can always update when edit always is set to 1.
 727         $entry->timecreated = time() - 2 * $CFG->maxeditingtime;
 728         $this->assertTrue(mod_glossary_can_update_entry($entry, $glossary, $context, $cm));
 729
 730         // Test student cannot update old entries when edit always is set to 0.
 731         $glossary->editalways = 0;
 732         $this->assertFalse(mod_glossary_can_update_entry($entry, $glossary, $context, $cm));
 733
 734         // Test student can update recent entries when edit always is set to 0.
 735         $entry->timecreated = time();
 736         $this->assertTrue(mod_glossary_can_update_entry($entry, $glossary, $context, $cm));
 737
 738         // Check exception.
 739         $entry->timecreated = time() - 2 * $CFG->maxeditingtime;
 740         $this->expectExceptionMessage(get_string('erredittimeexpired', 'glossary'));
 741         mod_glossary_can_update_entry($entry, $glossary, $context, $cm, false);
 742     }
 743
 744     public function test_prepare_entry_for_edition() {
 745         global $USER;
 746         $this->resetAfterTest(true);
 747
 748         $course = $this->getDataGenerator()->create_course();
 749         $glossary = $this->getDataGenerator()->create_module('glossary', ['course' => $course->id]);
 750         $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 751
 752         $this->setAdminUser();
 753         $aliases = ['alias1', 'alias2'];
 754         $entry = $gg->create_content(
 755             $glossary,
 756             ['approved' => 1, 'userid' => $USER->id],
 757             $aliases
 758         );
 759
 760         $cat1 = $gg->create_category($glossary, [], [$entry]);
 761         $gg->create_category($glossary);
 762
 763         $entry = mod_glossary_prepare_entry_for_edition($entry);
 764         $this->assertCount(1, $entry->categories);
 765         $this->assertEquals($cat1->id, $entry->categories[0]);
 766         $returnedaliases = array_values(explode("\n", trim($entry->aliases)));
 767         sort($returnedaliases);
 768         $this->assertEquals($aliases, $returnedaliases);
 769     }
 770 }