notes/tests/externallib_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  * External notes functions unit tests
  19  *
  20  * @package    core_notes
  21  * @category   external
  22  * @copyright  2012 Jerome Mouneyrac
  23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24  */
  25
  26 defined('MOODLE_INTERNAL') || die();
  27
  28 global $CFG;
  29
  30 require_once($CFG->dirroot . '/webservice/tests/helpers.php');
  31 require_once($CFG->dirroot . '/notes/externallib.php');
  32
  33 class core_notes_externallib_testcase extends externallib_advanced_testcase {
  34
  35     /**
  36      * Test create_notes
  37      */
  38     public function test_create_notes() {
  39
  40         global $DB, $USER;
  41
  42         $this->resetAfterTest(true);
  43
  44         $course = self::getDataGenerator()->create_course();
  45
  46         // Set the required capabilities by the external function.
  47         $contextid = context_course::instance($course->id)->id;
  48         $roleid = $this->assignUserCapability('moodle/notes:manage', $contextid);
  49         $this->assignUserCapability('moodle/course:view', $contextid, $roleid);
  50
  51         // Create test note data.
  52         $note1 = array();
  53         $note1['userid'] = $USER->id;
  54         $note1['publishstate'] = 'personal';
  55         $note1['courseid'] = $course->id;
  56         $note1['text'] = 'the text';
  57         $note1['clientnoteid'] = 4;
  58         $notes = array($note1);
  59
  60         $creatednotes = core_notes_external::create_notes($notes);
  61         // We need to execute the return values cleaning process to simulate the web service server.
  62         $creatednotes = external_api::clean_returnvalue(core_notes_external::create_notes_returns(), $creatednotes);
  63
  64         $thenote = $DB->get_record('post', array('id' => $creatednotes[0]['noteid']));
  65
  66         // Confirm that base note data was inserted correctly.
  67         $this->assertEquals($thenote->userid, $note1['userid']);
  68         $this->assertEquals($thenote->courseid, $note1['courseid']);
  69         $this->assertEquals($thenote->publishstate, NOTES_STATE_DRAFT);
  70         $this->assertEquals($thenote->content, $note1['text']);
  71         $this->assertEquals($creatednotes[0]['clientnoteid'], $note1['clientnoteid']);
  72
  73         // Call without required capability.
  74         $this->unassignUserCapability('moodle/notes:manage', $contextid, $roleid);
  75         $this->expectException('required_capability_exception');
  76         $creatednotes = core_notes_external::create_notes($notes);
  77     }
  78
  79     public function test_delete_notes() {
  80
  81         global $DB, $USER;
  82
  83         $this->resetAfterTest(true);
  84
  85         $course = self::getDataGenerator()->create_course();
  86
  87         // Set the required capabilities by the external function.
  88         $contextid = context_course::instance($course->id)->id;
  89         $roleid = $this->assignUserCapability('moodle/notes:manage', $contextid);
  90         $this->assignUserCapability('moodle/course:view', $contextid, $roleid);
  91
  92         // Create test note data.
  93         $cnote = array();
  94         $cnote['userid'] = $USER->id;
  95         $cnote['publishstate'] = 'personal';
  96         $cnote['courseid'] = $course->id;
  97         $cnote['text'] = 'the text';
  98         $cnote['clientnoteid'] = 4;
  99         $cnotes = array($cnote);
 100         $creatednotes = core_notes_external::create_notes($cnotes);
 101         $creatednotes = external_api::clean_returnvalue(core_notes_external::create_notes_returns(), $creatednotes);
 102
 103         $dnotes1 = array($creatednotes[0]['noteid']);
 104         $deletednotes1 = core_notes_external::delete_notes($dnotes1);
 105         $deletednotes1 = external_api::clean_returnvalue(core_notes_external::delete_notes_returns(), $deletednotes1);
 106
 107         // Confirm that base note data was deleted correctly.
 108         $notdeletedcount = $DB->count_records_select('post', 'id = ' . $creatednotes[0]['noteid']);
 109         $this->assertEquals(0, $notdeletedcount);
 110
 111         $dnotes2 = array(33); // This note does not exist.
 112         $deletednotes2 = core_notes_external::delete_notes($dnotes2);
 113         $deletednotes2 = external_api::clean_returnvalue(core_notes_external::delete_notes_returns(), $deletednotes2);
 114
 115         $this->assertEquals("note", $deletednotes2[0]["item"]);
 116         $this->assertEquals(33, $deletednotes2[0]["itemid"]);
 117         $this->assertEquals("badid", $deletednotes2[0]["warningcode"]);
 118         $this->assertEquals("Note does not exist", $deletednotes2[0]["message"]);
 119
 120         // Call without required capability.
 121         $creatednotes = core_notes_external::create_notes($cnotes);
 122         $creatednotes = external_api::clean_returnvalue(core_notes_external::create_notes_returns(), $creatednotes);
 123         $dnotes3 = array($creatednotes[0]['noteid']);
 124
 125         $this->unassignUserCapability('moodle/notes:manage', $contextid, $roleid);
 126         $this->expectException('required_capability_exception');
 127         $deletednotes = core_notes_external::delete_notes($dnotes3);
 128         $deletednotes = external_api::clean_returnvalue(core_notes_external::delete_notes_returns(), $deletednotes);
 129     }
 130
 131     public function test_get_notes() {
 132
 133         global $DB, $USER;
 134
 135         $this->resetAfterTest(true);
 136
 137         $course = self::getDataGenerator()->create_course();
 138
 139         // Set the required capabilities by the external function.
 140         $contextid = context_course::instance($course->id)->id;
 141         $roleid = $this->assignUserCapability('moodle/notes:manage', $contextid);
 142         $this->assignUserCapability('moodle/notes:view', $contextid, $roleid);
 143         $this->assignUserCapability('moodle/course:view', $contextid, $roleid);
 144
 145         // Create test note data.
 146         $cnote = array();
 147         $cnote['userid'] = $USER->id;
 148         $cnote['publishstate'] = 'personal';
 149         $cnote['courseid'] = $course->id;
 150         $cnote['text'] = 'the text';
 151         $cnotes = array($cnote);
 152
 153         $creatednotes1 = core_notes_external::create_notes($cnotes);
 154         $creatednotes2 = core_notes_external::create_notes($cnotes);
 155         $creatednotes3 = core_notes_external::create_notes($cnotes);
 156
 157         $creatednotes1 = external_api::clean_returnvalue(core_notes_external::create_notes_returns(), $creatednotes1);
 158         $creatednotes2 = external_api::clean_returnvalue(core_notes_external::create_notes_returns(), $creatednotes2);
 159         $creatednotes3 = external_api::clean_returnvalue(core_notes_external::create_notes_returns(), $creatednotes3);
 160
 161         // Note 33 does not exist.
 162         $gnotes = array($creatednotes1[0]['noteid'], $creatednotes2[0]['noteid'], $creatednotes3[0]['noteid'], 33);
 163         $getnotes = core_notes_external::get_notes($gnotes);
 164         $getnotes = external_api::clean_returnvalue(core_notes_external::get_notes_returns(), $getnotes);
 165
 166         $this->unassignUserCapability('moodle/notes:manage', $contextid, $roleid);
 167         // Confirm that base note data was retrieved correctly.
 168         $this->assertEquals($cnote['userid'], $getnotes["notes"][0]["userid"]);
 169         $this->assertEquals($cnote['text'], $getnotes["notes"][0]["text"]);
 170         $this->assertEquals($cnote['userid'], $getnotes["notes"][1]["userid"]);
 171         $this->assertEquals($cnote['text'], $getnotes["notes"][1]["text"]);
 172         $this->assertEquals($cnote['userid'], $getnotes["notes"][2]["userid"]);
 173         $this->assertEquals($cnote['text'], $getnotes["notes"][2]["text"]);
 174         $this->assertEquals("note", $getnotes["warnings"][0]["item"]);
 175         $this->assertEquals(33, $getnotes["warnings"][0]["itemid"]);
 176         $this->assertEquals("badid", $getnotes["warnings"][0]["warningcode"]);
 177         $this->assertEquals("Note does not exist", $getnotes["warnings"][0]["message"]);
 178
 179         // Call without required capability.
 180         $this->unassignUserCapability('moodle/notes:view', $contextid, $roleid);
 181         $this->expectException('required_capability_exception');
 182         $creatednotes = core_notes_external::get_notes($gnotes);
 183     }
 184
 185     public function test_update_notes() {
 186
 187         global $DB, $USER;
 188
 189         $this->resetAfterTest(true);
 190
 191         $course = self::getDataGenerator()->create_course();
 192
 193         // Set the required capabilities by the external function.
 194         $contextid = context_course::instance($course->id)->id;
 195         $roleid = $this->assignUserCapability('moodle/notes:manage', $contextid);
 196         $this->assignUserCapability('moodle/course:view', $contextid, $roleid);
 197
 198         // Create test note data.
 199         $note1 = array();
 200         $note1['userid'] = $USER->id;
 201         $note1['publishstate'] = 'personal';
 202         $note1['courseid'] = $course->id;
 203         $note1['text'] = 'the text';
 204         $note2['userid'] = $USER->id;
 205         $note2['publishstate'] = 'course';
 206         $note2['courseid'] = $course->id;
 207         $note2['text'] = 'the text';
 208         $note3['userid'] = $USER->id;
 209         $note3['publishstate'] = 'site';
 210         $note3['courseid'] = $course->id;
 211         $note3['text'] = 'the text';
 212         $notes1 = array($note1, $note2, $note3);
 213
 214         $creatednotes = core_notes_external::create_notes($notes1);
 215         $creatednotes = external_api::clean_returnvalue(core_notes_external::create_notes_returns(), $creatednotes);
 216
 217         $note2 = array();
 218         $note2["id"] = $creatednotes[0]['noteid'];
 219         $note2['publishstate'] = 'personal';
 220         $note2['text'] = 'the new text';
 221         $note2['format'] = FORMAT_HTML;
 222         $notes2 = array($note2);
 223
 224         $updatednotes = core_notes_external::update_notes($notes2);
 225
 226         $updatednotes = external_api::clean_returnvalue(core_notes_external::update_notes_returns(), $updatednotes);
 227         $thenote = $DB->get_record('post', array('id' => $creatednotes[0]['noteid']));
 228
 229         // Confirm that base note data was updated correctly.
 230         $this->assertEquals($thenote->publishstate, NOTES_STATE_DRAFT);
 231         $this->assertEquals($note2['text'], $thenote->content);
 232
 233         // Call without required capability.
 234         $creatednotes = core_notes_external::create_notes($notes1);
 235         $creatednotes = external_api::clean_returnvalue(core_notes_external::create_notes_returns(), $creatednotes);
 236         $this->unassignUserCapability('moodle/notes:manage', $contextid, $roleid);
 237         $this->expectException('required_capability_exception');
 238         $note2 = array();
 239         $note2["id"] = $creatednotes[0]['noteid'];
 240         $note2['publishstate'] = 'personal';
 241         $note2['text'] = 'the new text';
 242         $note2['format'] = FORMAT_HTML;
 243         $notes2 = array($note2);
 244         $updatednotes = core_notes_external::update_notes($notes2);
 245         $updatednotes = external_api::clean_returnvalue(core_notes_external::update_notes_returns(), $updatednotes);
 246     }
 247
 248     /**
 249      * Test get_course_notes
 250      */
 251     public function test_get_course_notes() {
 252         global $DB, $CFG;
 253
 254         $this->resetAfterTest(true);
 255         $CFG->enablenotes = true;
 256
 257         // Take role definitions.
 258         $studentrole = $DB->get_record('role', array('shortname' => 'student'));
 259         $teacherrole = $DB->get_record('role', array('shortname' => 'teacher'));
 260
 261         // Create students and teachers.
 262         $student1 = $this->getDataGenerator()->create_user();
 263         $student2 = $this->getDataGenerator()->create_user();
 264         $teacher1 = $this->getDataGenerator()->create_user();
 265         $teacher2 = $this->getDataGenerator()->create_user();
 266         $course1 = $this->getDataGenerator()->create_course();
 267         $course2 = $this->getDataGenerator()->create_course();
 268
 269         // Enroll students and teachers to COURSE-1.
 270         $this->getDataGenerator()->enrol_user($student1->id, $course1->id, $studentrole->id);
 271         $this->getDataGenerator()->enrol_user($student2->id, $course1->id, $studentrole->id);
 272         $this->getDataGenerator()->enrol_user($teacher1->id, $course1->id, $teacherrole->id);
 273         $this->getDataGenerator()->enrol_user($teacher2->id, $course1->id, $teacherrole->id);
 274         // Enroll students and teachers to COURSE-2 (teacher1 is not enrolled in Course 2).
 275         $this->getDataGenerator()->enrol_user($student1->id, $course2->id, $studentrole->id);
 276         $this->getDataGenerator()->enrol_user($student2->id, $course2->id, $studentrole->id);
 277
 278         $this->getDataGenerator()->enrol_user($teacher2->id, $course2->id, $teacherrole->id);
 279
 280         // Generate notes.
 281         $gen = $this->getDataGenerator()->get_plugin_generator('core_notes');
 282
 283         $this->setUser($teacher1);
 284
 285         // NoteA1: on student1 (Course1) by Teacher1.
 286         $params = array('courseid' => $course1->id, 'userid' => $student1->id, 'publishstate' => NOTES_STATE_PUBLIC,
 287             'usermodified' => $teacher1->id);
 288         $notea1 = $gen->create_instance($params);
 289         // NoteA2: on student1 (Course1) by Teacher1.
 290         $params = array('courseid' => $course1->id, 'userid' => $student1->id, 'publishstate' => NOTES_STATE_PUBLIC,
 291             'usermodified' => $teacher1->id);
 292         $notea2 = $gen->create_instance($params);
 293         // NoteS1: on student1 SITE-LEVEL by teacher1.
 294         $params = array('courseid' => $course1->id, 'userid' => $student1->id, 'publishstate' => NOTES_STATE_SITE,
 295             'usermodified' => $teacher1->id);
 296         $notes1 = $gen->create_instance($params);
 297         // NoteP1: on student1 PERSONAL by teacher1.
 298         $params = array('courseid' => $course1->id, 'userid' => $student1->id, 'publishstate' => NOTES_STATE_DRAFT,
 299             'usermodified' => $teacher1->id);
 300         $notep1 = $gen->create_instance($params);
 301         // NoteB1: on student1 (Course2) by teacher1.
 302         $params = array('courseid' => $course2->id, 'userid' => $student1->id, 'publishstate' => NOTES_STATE_PUBLIC,
 303             'usermodified' => $teacher1->id);
 304         $noteb1 = $gen->create_instance($params);
 305
 306         // Retrieve notes, normal case.
 307         $result = core_notes_external::get_course_notes($course1->id, $student1->id);
 308         $result = external_api::clean_returnvalue(core_notes_external::get_course_notes_returns(), $result);
 309         $this->assertEquals($notes1->id, $result['sitenotes'][0]['id']);
 310         $this->assertCount(2, $result['coursenotes']);
 311
 312         foreach ($result['coursenotes'] as $coursenote) {
 313             if ($coursenote['id'] != $notea1->id and $coursenote['id'] != $notea2->id) {
 314                 $this->fail('the returned notes ids does not match with the created ones');
 315             }
 316         }
 317
 318         $this->assertEquals($notep1->id, $result['personalnotes'][0]['id']);
 319
 320         // Try to get notes from a course the user is not enrolled.
 321         try {
 322             $result = core_notes_external::get_course_notes($course2->id, $student1->id);
 323             $this->fail('the user is not enrolled in the course');
 324         } catch (require_login_exception $e) {
 325             $this->assertEquals('requireloginerror', $e->errorcode);
 326         }
 327
 328         $result = core_notes_external::get_course_notes(0, $student1->id);
 329         $result = external_api::clean_returnvalue(core_notes_external::get_course_notes_returns(), $result);
 330         $this->assertEmpty($result['sitenotes']);
 331
 332         foreach ($result['coursenotes'] as $coursenote) {
 333             if ($coursenote['id'] != $notea1->id and $coursenote['id'] != $notea2->id) {
 334                 $this->fail('the returned notes ids does not match with the created ones');
 335             }
 336         }
 337
 338         $this->assertCount(2, $result['coursenotes']);
 339
 340         $this->setAdminUser();
 341         $result = core_notes_external::get_course_notes(0, $student1->id);
 342         $result = external_api::clean_returnvalue(core_notes_external::get_course_notes_returns(), $result);
 343         $this->assertEquals($notes1->id, $result['sitenotes'][0]['id']);
 344         $this->assertCount(1, $result['sitenotes']);
 345
 346         $this->setUser($teacher1);
 347         $result = core_notes_external::get_course_notes(0, 0);
 348         $result = external_api::clean_returnvalue(core_notes_external::get_course_notes_returns(), $result);
 349         $this->assertEmpty($result['sitenotes']);
 350         $this->assertEmpty($result['coursenotes']);
 351         $this->assertEmpty($result['personalnotes']);
 352
 353         $this->setUser($teacher2);
 354         $result = core_notes_external::get_course_notes($course1->id, $student1->id);
 355         $result = external_api::clean_returnvalue(core_notes_external::get_course_notes_returns(), $result);
 356         $this->assertEquals($notes1->id, $result['sitenotes'][0]['id']);
 357
 358         foreach ($result['coursenotes'] as $coursenote) {
 359             if ($coursenote['id'] != $notea1->id and $coursenote['id'] != $notea2->id) {
 360                 $this->fail('the returned notes ids does not match with the created ones');
 361             }
 362         }
 363
 364         $this->assertCount(1, $result['sitenotes']);
 365         $this->assertCount(2, $result['coursenotes']);
 366
 367         $result = core_notes_external::get_course_notes($course1->id, 0);
 368         $result = external_api::clean_returnvalue(core_notes_external::get_course_notes_returns(), $result);
 369         $this->assertEquals($notes1->id, $result['sitenotes'][0]['id']);
 370
 371         foreach ($result['coursenotes'] as $coursenote) {
 372             if ($coursenote['id'] != $notea1->id and $coursenote['id'] != $notea2->id) {
 373                 $this->fail('the returned notes ids does not match with the created ones');
 374             }
 375         }
 376
 377         $this->assertCount(1, $result['sitenotes']);
 378         $this->assertCount(2, $result['coursenotes']);
 379
 380         $this->setUser($teacher1);
 381         $result = core_notes_external::get_course_notes($course1->id, 0);
 382         $result = external_api::clean_returnvalue(core_notes_external::get_course_notes_returns(), $result);
 383         $this->assertEquals($notep1->id, $result['personalnotes'][0]['id']);
 384         $this->assertCount(1, $result['personalnotes']);
 385
 386     }
 387
 388     /**
 389      * Test view_notes
 390      */
 391     public function test_view_notes() {
 392         global $DB, $CFG;
 393
 394         $this->resetAfterTest(true);
 395         $CFG->enablenotes = true;
 396
 397         // Take role definitions.
 398         $studentrole = $DB->get_record('role', array('shortname' => 'student'));
 399         $teacherrole = $DB->get_record('role', array('shortname' => 'teacher'));
 400
 401         // Create students and teachers.
 402         $student = $this->getDataGenerator()->create_user();
 403         $teacher = $this->getDataGenerator()->create_user();
 404         $course = $this->getDataGenerator()->create_course();
 405         $coursecontext = context_course::instance($course->id);
 406
 407         // Enroll students and teachers to course.
 408         $this->getDataGenerator()->enrol_user($student->id, $course->id, $studentrole->id);
 409         $this->getDataGenerator()->enrol_user($teacher->id, $course->id, $teacherrole->id);
 410
 411         // Generate notes.
 412         $gen = $this->getDataGenerator()->get_plugin_generator('core_notes');
 413         $this->setUser($teacher);
 414
 415         // NoteA1: on student (Course) by Teacher.
 416         $params = array('courseid' => $course->id, 'userid' => $student->id, 'publishstate' => NOTES_STATE_PUBLIC,
 417             'usermodified' => $teacher->id);
 418         $notea1 = $gen->create_instance($params);
 419
 420         $sink = $this->redirectEvents();
 421
 422         $result = core_notes_external::view_notes($course->id, $student->id);
 423         $result = external_api::clean_returnvalue(core_notes_external::view_notes_returns(), $result);
 424
 425         $result = core_notes_external::view_notes($course->id);
 426         $result = external_api::clean_returnvalue(core_notes_external::view_notes_returns(), $result);
 427
 428         $events = $sink->get_events();
 429
 430         $this->assertCount(2, $events);
 431
 432         $this->assertInstanceOf('\core\event\notes_viewed', $events[0]);
 433         $this->assertEquals($coursecontext, $events[0]->get_context());
 434         $this->assertEquals($student->id, $events[0]->relateduserid);
 435
 436         $this->assertInstanceOf('\core\event\notes_viewed', $events[1]);
 437         $this->assertEquals($coursecontext, $events[1]->get_context());
 438         $this->assertEquals(0, $events[1]->relateduserid);
 439
 440         try {
 441             core_notes_external::view_notes(0);
 442             $this->fail('Exception expected due to invalid permissions at system level.');
 443         } catch (moodle_exception $e) {
 444             $this->assertEquals('nopermissions', $e->errorcode);
 445         }
 446
 447         try {
 448             core_notes_external::view_notes($course->id, $student->id + 100);
 449             $this->fail('Exception expected due to invalid user id.');
 450         } catch (moodle_exception $e) {
 451             $this->assertEquals('invaliduser', $e->errorcode);
 452         }
 453     }
 454 }