[ Index ]

PHP Cross Reference of Unnamed Project

title

Body

[close]

/mod/glossary/tests/ -> external_test.php (source)

   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 glossary functions unit tests
  19   *
  20   * @package    mod_glossary
  21   * @category   external
  22   * @copyright  2015 Costantino Cito <ccito@cvaconsulting.com>
  23   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24   */
  25  
  26  defined('MOODLE_INTERNAL') || die();
  27  global $CFG;
  28  require_once($CFG->dirroot . '/webservice/tests/helpers.php');
  29  
  30  /**
  31   * External glossary functions unit tests
  32   *
  33   * @package    mod_glossary
  34   * @category   external
  35   * @copyright  2015 Costantino Cito <ccito@cvaconsulting.com>
  36   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  37   */
  38  class mod_glossary_external_testcase extends externallib_advanced_testcase {
  39  
  40      /**
  41       * Test get_glossaries_by_courses
  42       */
  43      public function test_get_glossaries_by_courses() {
  44          $this->resetAfterTest(true);
  45  
  46          // As admin.
  47          $this->setAdminUser();
  48          $c1 = self::getDataGenerator()->create_course();
  49          $c2 = self::getDataGenerator()->create_course();
  50          $g1 = self::getDataGenerator()->create_module('glossary', array('course' => $c1->id, 'name' => 'First Glossary'));
  51          $g2 = self::getDataGenerator()->create_module('glossary', array('course' => $c1->id, 'name' => 'Second Glossary'));
  52          $g3 = self::getDataGenerator()->create_module('glossary', array('course' => $c2->id, 'name' => 'Third Glossary'));
  53  
  54          $s1 = $this->getDataGenerator()->create_user();
  55          self::getDataGenerator()->enrol_user($s1->id,  $c1->id);
  56  
  57          // Check results where student is enrolled.
  58          $this->setUser($s1);
  59          $glossaries = mod_glossary_external::get_glossaries_by_courses(array());
  60          $glossaries = external_api::clean_returnvalue(mod_glossary_external::get_glossaries_by_courses_returns(), $glossaries);
  61  
  62          $this->assertCount(2, $glossaries['glossaries']);
  63          $this->assertEquals('First Glossary', $glossaries['glossaries'][0]['name']);
  64          $this->assertEquals('Second Glossary', $glossaries['glossaries'][1]['name']);
  65  
  66          // Check results with specific course IDs.
  67          $glossaries = mod_glossary_external::get_glossaries_by_courses(array($c1->id, $c2->id));
  68          $glossaries = external_api::clean_returnvalue(mod_glossary_external::get_glossaries_by_courses_returns(), $glossaries);
  69  
  70          $this->assertCount(2, $glossaries['glossaries']);
  71          $this->assertEquals('First Glossary', $glossaries['glossaries'][0]['name']);
  72          $this->assertEquals('Second Glossary', $glossaries['glossaries'][1]['name']);
  73  
  74          $this->assertEquals('course', $glossaries['warnings'][0]['item']);
  75          $this->assertEquals($c2->id, $glossaries['warnings'][0]['itemid']);
  76          $this->assertEquals('1', $glossaries['warnings'][0]['warningcode']);
  77  
  78          // Now as admin.
  79          $this->setAdminUser();
  80  
  81          $glossaries = mod_glossary_external::get_glossaries_by_courses(array($c2->id));
  82          $glossaries = external_api::clean_returnvalue(mod_glossary_external::get_glossaries_by_courses_returns(), $glossaries);
  83  
  84          $this->assertCount(1, $glossaries['glossaries']);
  85          $this->assertEquals('Third Glossary', $glossaries['glossaries'][0]['name']);
  86      }
  87  
  88      public function test_view_glossary() {
  89          $this->resetAfterTest(true);
  90  
  91          // Generate all the things.
  92          $c1 = $this->getDataGenerator()->create_course();
  93          $g1 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
  94          $u1 = $this->getDataGenerator()->create_user();
  95          $this->getDataGenerator()->enrol_user($u1->id, $c1->id);
  96  
  97          $sink = $this->redirectEvents();
  98          $this->setUser($u1);
  99          $return = mod_glossary_external::view_glossary($g1->id, 'letter');
 100          $return = external_api::clean_returnvalue(mod_glossary_external::view_glossary_returns(), $return);
 101          $events = $sink->get_events();
 102  
 103          // Assertion.
 104          $this->assertTrue($return['status']);
 105          $this->assertEmpty($return['warnings']);
 106          $this->assertCount(1, $events);
 107          $this->assertEquals('\mod_glossary\event\course_module_viewed', $events[0]->eventname);
 108          $sink->close();
 109      }
 110  
 111      /**
 112       * @expectedException        require_login_exception
 113       * @expectedExceptionMessage Activity is hidden
 114       */
 115      public function test_view_glossary_without_permission() {
 116          $this->resetAfterTest(true);
 117  
 118          // Generate all the things.
 119          $c1 = $this->getDataGenerator()->create_course();
 120          $g1 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 121          $u1 = $this->getDataGenerator()->create_user();
 122          $this->getDataGenerator()->enrol_user($u1->id, $c1->id);
 123          $ctx = context_module::instance($g1->cmid);
 124  
 125          // Revoke permission.
 126          $roles = get_archetype_roles('user');
 127          $role = array_shift($roles);
 128          assign_capability('mod/glossary:view', CAP_PROHIBIT, $role->id, $ctx, true);
 129          accesslib_clear_all_caches_for_unit_testing();
 130  
 131          // Assertion.
 132          $this->setUser($u1);
 133          mod_glossary_external::view_glossary($g1->id, 'letter');
 134      }
 135  
 136      /**
 137       * @expectedException        require_login_exception
 138       * @expectedExceptionMessage Activity is hidden
 139       */
 140      public function test_view_entry() {
 141          $this->resetAfterTest(true);
 142  
 143          // Generate all the things.
 144          $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 145          $c1 = $this->getDataGenerator()->create_course();
 146          $g1 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 147          $g2 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id, 'visible' => false));
 148          $u1 = $this->getDataGenerator()->create_user();
 149          $e1 = $gg->create_content($g1, array('approved' => 1));
 150          $e2 = $gg->create_content($g1, array('approved' => 0, 'userid' => $u1->id));
 151          $e3 = $gg->create_content($g1, array('approved' => 0, 'userid' => -1));
 152          $e4 = $gg->create_content($g2, array('approved' => 1));
 153          $ctx = context_module::instance($g1->cmid);
 154          $this->getDataGenerator()->enrol_user($u1->id, $c1->id);
 155          $this->setUser($u1);
 156  
 157          // Test readable entry.
 158          $sink = $this->redirectEvents();
 159          $return = mod_glossary_external::view_entry($e1->id);
 160          $return = external_api::clean_returnvalue(mod_glossary_external::view_entry_returns(), $return);
 161          $events = $sink->get_events();
 162          $this->assertTrue($return['status']);
 163          $this->assertEmpty($return['warnings']);
 164          $this->assertCount(1, $events);
 165          $this->assertEquals('\mod_glossary\event\entry_viewed', $events[0]->eventname);
 166          $sink->close();
 167  
 168          // Test non-approved of self.
 169          $return = mod_glossary_external::view_entry($e2->id);
 170          $return = external_api::clean_returnvalue(mod_glossary_external::view_entry_returns(), $return);
 171          $events = $sink->get_events();
 172          $this->assertTrue($return['status']);
 173          $this->assertEmpty($return['warnings']);
 174          $this->assertCount(1, $events);
 175          $this->assertEquals('\mod_glossary\event\entry_viewed', $events[0]->eventname);
 176          $sink->close();
 177  
 178          // Test non-approved of other.
 179          try {
 180              mod_glossary_external::view_entry($e3->id);
 181              $this->fail('Cannot view non-approved entries of others.');
 182          } catch (invalid_parameter_exception $e) {
 183              // All good.
 184          }
 185  
 186          // Test non-readable entry.
 187          mod_glossary_external::view_entry($e4->id);
 188      }
 189  
 190      public function test_get_entries_by_letter() {
 191          $this->resetAfterTest(true);
 192  
 193          // Generate all the things.
 194          $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 195          $c1 = $this->getDataGenerator()->create_course();
 196          $g1 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 197          $g2 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 198          $u1 = $this->getDataGenerator()->create_user();
 199          $ctx = context_module::instance($g1->cmid);
 200          $this->getDataGenerator()->enrol_user($u1->id, $c1->id);
 201  
 202          $e1a = $gg->create_content($g1, array('approved' => 0, 'concept' => 'Bob', 'userid' => 2));
 203          $e1b = $gg->create_content($g1, array('approved' => 1, 'concept' => 'Jane', 'userid' => 2));
 204          $e1c = $gg->create_content($g1, array('approved' => 1, 'concept' => 'Alice', 'userid' => $u1->id));
 205          $e1d = $gg->create_content($g1, array('approved' => 0, 'concept' => '0-day', 'userid' => $u1->id));
 206          $e2a = $gg->create_content($g2);
 207  
 208          $this->setAdminUser();
 209  
 210          // Just a normal request from admin user.
 211          $return = mod_glossary_external::get_entries_by_letter($g1->id, 'ALL', 0, 20, array());
 212          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_letter_returns(), $return);
 213          $this->assertCount(3, $return['entries']);
 214          $this->assertEquals(3, $return['count']);
 215          $this->assertEquals($e1c->id, $return['entries'][0]['id']);
 216          $this->assertEquals($e1a->id, $return['entries'][1]['id']);
 217          $this->assertEquals($e1b->id, $return['entries'][2]['id']);
 218  
 219          // An admin user requesting all the entries.
 220          $return = mod_glossary_external::get_entries_by_letter($g1->id, 'ALL', 0, 20, array('includenotapproved' => 1));
 221          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_letter_returns(), $return);
 222          $this->assertCount(4, $return['entries']);
 223          $this->assertEquals(4, $return['count']);
 224          $this->assertEquals($e1d->id, $return['entries'][0]['id']);
 225          $this->assertEquals($e1c->id, $return['entries'][1]['id']);
 226          $this->assertEquals($e1a->id, $return['entries'][2]['id']);
 227          $this->assertEquals($e1b->id, $return['entries'][3]['id']);
 228  
 229          // A normal user.
 230          $this->setUser($u1);
 231          $return = mod_glossary_external::get_entries_by_letter($g1->id, 'ALL', 0, 20, array());
 232          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_letter_returns(), $return);
 233          $this->assertCount(3, $return['entries']);
 234          $this->assertEquals(3, $return['count']);
 235          $this->assertEquals($e1d->id, $return['entries'][0]['id']);
 236          $this->assertEquals($e1c->id, $return['entries'][1]['id']);
 237          $this->assertEquals($e1b->id, $return['entries'][2]['id']);
 238  
 239          // A normal user requesting to view all non approved entries.
 240          $return = mod_glossary_external::get_entries_by_letter($g1->id, 'ALL', 0, 20, array('includenotapproved' => 1));
 241          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_letter_returns(), $return);
 242          $this->assertCount(3, $return['entries']);
 243          $this->assertEquals(3, $return['count']);
 244          $this->assertEquals($e1d->id, $return['entries'][0]['id']);
 245          $this->assertEquals($e1c->id, $return['entries'][1]['id']);
 246          $this->assertEquals($e1b->id, $return['entries'][2]['id']);
 247      }
 248  
 249      public function test_get_entries_by_letter_with_parameters() {
 250          $this->resetAfterTest(true);
 251  
 252          // Generate all the things.
 253          $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 254          $c1 = $this->getDataGenerator()->create_course();
 255          $g1 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 256          $u1 = $this->getDataGenerator()->create_user();
 257          $ctx = context_module::instance($g1->cmid);
 258          $this->getDataGenerator()->enrol_user($u1->id, $c1->id);
 259  
 260          $e1a = $gg->create_content($g1, array('approved' => 1, 'concept' => '0-day', 'userid' => $u1->id));
 261          $e1b = $gg->create_content($g1, array('approved' => 1, 'concept' => 'Bob', 'userid' => 2));
 262          $e1c = $gg->create_content($g1, array('approved' => 1, 'concept' => '1-dayb', 'userid' => $u1->id));
 263  
 264          $this->setUser($u1);
 265  
 266          // Requesting a single letter.
 267          $return = mod_glossary_external::get_entries_by_letter($g1->id, 'b', 0, 20, array());
 268          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_letter_returns(), $return);
 269          $this->assertCount(1, $return['entries']);
 270          $this->assertEquals(1, $return['count']);
 271          $this->assertEquals($e1b->id, $return['entries'][0]['id']);
 272  
 273          // Requesting special letters.
 274          $return = mod_glossary_external::get_entries_by_letter($g1->id, 'SPECIAL', 0, 20, array());
 275          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_letter_returns(), $return);
 276          $this->assertCount(2, $return['entries']);
 277          $this->assertEquals(2, $return['count']);
 278          $this->assertEquals($e1a->id, $return['entries'][0]['id']);
 279          $this->assertEquals($e1c->id, $return['entries'][1]['id']);
 280  
 281          // Requesting with limit.
 282          $return = mod_glossary_external::get_entries_by_letter($g1->id, 'ALL', 0, 1, array());
 283          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_letter_returns(), $return);
 284          $this->assertCount(1, $return['entries']);
 285          $this->assertEquals(3, $return['count']);
 286          $this->assertEquals($e1a->id, $return['entries'][0]['id']);
 287          $return = mod_glossary_external::get_entries_by_letter($g1->id, 'ALL', 1, 2, array());
 288          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_letter_returns(), $return);
 289          $this->assertCount(2, $return['entries']);
 290          $this->assertEquals(3, $return['count']);
 291          $this->assertEquals($e1c->id, $return['entries'][0]['id']);
 292          $this->assertEquals($e1b->id, $return['entries'][1]['id']);
 293      }
 294  
 295      public function test_get_entries_by_date() {
 296          global $DB;
 297          $this->resetAfterTest(true);
 298  
 299          // Generate all the things.
 300          $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 301          $c1 = $this->getDataGenerator()->create_course();
 302          $g1 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id, 'displayformat' => 'entrylist'));
 303          $g2 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 304          $u1 = $this->getDataGenerator()->create_user();
 305          $ctx = context_module::instance($g1->cmid);
 306          $this->getDataGenerator()->enrol_user($u1->id, $c1->id);
 307  
 308          $now = time();
 309          $e1a = $gg->create_content($g1, array('approved' => 1, 'concept' => 'Bob', 'userid' => $u1->id,
 310              'timecreated' => 1, 'timemodified' => $now + 3600));
 311          $e1b = $gg->create_content($g1, array('approved' => 1, 'concept' => 'Jane', 'userid' => $u1->id,
 312              'timecreated' => $now + 3600, 'timemodified' => 1));
 313          $e1c = $gg->create_content($g1, array('approved' => 1, 'concept' => 'Alice', 'userid' => $u1->id,
 314              'timecreated' => $now + 1, 'timemodified' => $now + 1));
 315          $e1d = $gg->create_content($g1, array('approved' => 0, 'concept' => '0-day', 'userid' => $u1->id,
 316              'timecreated' => $now + 2, 'timemodified' => $now + 2));
 317          $e2a = $gg->create_content($g2);
 318  
 319          $this->setAdminUser($u1);
 320  
 321          // Ordering by time modified descending.
 322          $return = mod_glossary_external::get_entries_by_date($g1->id, 'UPDATE', 'DESC', 0, 20, array());
 323          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_date_returns(), $return);
 324          $this->assertCount(3, $return['entries']);
 325          $this->assertEquals(3, $return['count']);
 326          $this->assertEquals($e1a->id, $return['entries'][0]['id']);
 327          $this->assertEquals($e1c->id, $return['entries'][1]['id']);
 328          $this->assertEquals($e1b->id, $return['entries'][2]['id']);
 329  
 330          // Ordering by time modified ascending.
 331          $return = mod_glossary_external::get_entries_by_date($g1->id, 'UPDATE', 'ASC', 0, 20, array());
 332          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_date_returns(), $return);
 333          $this->assertCount(3, $return['entries']);
 334          $this->assertEquals(3, $return['count']);
 335          $this->assertEquals($e1b->id, $return['entries'][0]['id']);
 336          $this->assertEquals($e1c->id, $return['entries'][1]['id']);
 337          $this->assertEquals($e1a->id, $return['entries'][2]['id']);
 338  
 339          // Ordering by time created asc.
 340          $return = mod_glossary_external::get_entries_by_date($g1->id, 'CREATION', 'ASC', 0, 20, array());
 341          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_date_returns(), $return);
 342          $this->assertCount(3, $return['entries']);
 343          $this->assertEquals(3, $return['count']);
 344          $this->assertEquals($e1a->id, $return['entries'][0]['id']);
 345          $this->assertEquals($e1c->id, $return['entries'][1]['id']);
 346          $this->assertEquals($e1b->id, $return['entries'][2]['id']);
 347  
 348          // Ordering by time created descending.
 349          $return = mod_glossary_external::get_entries_by_date($g1->id, 'CREATION', 'DESC', 0, 20, array());
 350          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_date_returns(), $return);
 351          $this->assertCount(3, $return['entries']);
 352          $this->assertEquals(3, $return['count']);
 353          $this->assertEquals($e1b->id, $return['entries'][0]['id']);
 354          $this->assertEquals($e1c->id, $return['entries'][1]['id']);
 355          $this->assertEquals($e1a->id, $return['entries'][2]['id']);
 356  
 357          // Ordering including to approve.
 358          $return = mod_glossary_external::get_entries_by_date($g1->id, 'CREATION', 'ASC', 0, 20,
 359              array('includenotapproved' => true));
 360          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_date_returns(), $return);
 361          $this->assertCount(4, $return['entries']);
 362          $this->assertEquals(4, $return['count']);
 363          $this->assertEquals($e1a->id, $return['entries'][0]['id']);
 364          $this->assertEquals($e1c->id, $return['entries'][1]['id']);
 365          $this->assertEquals($e1d->id, $return['entries'][2]['id']);
 366          $this->assertEquals($e1b->id, $return['entries'][3]['id']);
 367  
 368          // Ordering including to approve and pagination.
 369          $return = mod_glossary_external::get_entries_by_date($g1->id, 'CREATION', 'ASC', 0, 2,
 370              array('includenotapproved' => true));
 371          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_date_returns(), $return);
 372          $this->assertCount(2, $return['entries']);
 373          $this->assertEquals(4, $return['count']);
 374          $this->assertEquals($e1a->id, $return['entries'][0]['id']);
 375          $this->assertEquals($e1c->id, $return['entries'][1]['id']);
 376          $return = mod_glossary_external::get_entries_by_date($g1->id, 'CREATION', 'ASC', 2, 2,
 377              array('includenotapproved' => true));
 378          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_date_returns(), $return);
 379          $this->assertCount(2, $return['entries']);
 380          $this->assertEquals(4, $return['count']);
 381          $this->assertEquals($e1d->id, $return['entries'][0]['id']);
 382          $this->assertEquals($e1b->id, $return['entries'][1]['id']);
 383      }
 384  
 385      public function test_get_categories() {
 386          $this->resetAfterTest(true);
 387          $this->setAdminUser();
 388  
 389          $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 390          $c1 = $this->getDataGenerator()->create_course();
 391          $g1 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 392          $g2 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 393          $cat1a = $gg->create_category($g1);
 394          $cat1b = $gg->create_category($g1);
 395          $cat1c = $gg->create_category($g1);
 396          $cat2a = $gg->create_category($g2);
 397  
 398          $return = mod_glossary_external::get_categories($g1->id, 0, 20);
 399          $return = external_api::clean_returnvalue(mod_glossary_external::get_categories_returns(), $return);
 400          $this->assertCount(3, $return['categories']);
 401          $this->assertEquals(3, $return['count']);
 402          $this->assertEquals($cat1a->id, $return['categories'][0]['id']);
 403          $this->assertEquals($cat1b->id, $return['categories'][1]['id']);
 404          $this->assertEquals($cat1c->id, $return['categories'][2]['id']);
 405  
 406          $return = mod_glossary_external::get_categories($g1->id, 1, 2);
 407          $return = external_api::clean_returnvalue(mod_glossary_external::get_categories_returns(), $return);
 408          $this->assertCount(2, $return['categories']);
 409          $this->assertEquals(3, $return['count']);
 410          $this->assertEquals($cat1b->id, $return['categories'][0]['id']);
 411          $this->assertEquals($cat1c->id, $return['categories'][1]['id']);
 412      }
 413  
 414      public function test_get_entries_by_category() {
 415          $this->resetAfterTest(true);
 416  
 417          $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 418          $c1 = $this->getDataGenerator()->create_course();
 419          $g1 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id, 'displayformat' => 'entrylist'));
 420          $g2 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id, 'displayformat' => 'entrylist'));
 421          $u1 = $this->getDataGenerator()->create_user();
 422          $ctx = context_module::instance($g1->cmid);
 423  
 424          $e1a1 = $gg->create_content($g1, array('approved' => 1, 'userid' => $u1->id));
 425          $e1a2 = $gg->create_content($g1, array('approved' => 1, 'userid' => $u1->id));
 426          $e1a3 = $gg->create_content($g1, array('approved' => 1, 'userid' => $u1->id));
 427          $e1b1 = $gg->create_content($g1, array('approved' => 1, 'userid' => $u1->id));
 428          $e1b2 = $gg->create_content($g1, array('approved' => 0, 'userid' => $u1->id));
 429          $e1x1 = $gg->create_content($g1, array('approved' => 1, 'userid' => $u1->id));
 430          $e1x2 = $gg->create_content($g1, array('approved' => 0, 'userid' => $u1->id));
 431          $e2a1 = $gg->create_content($g2, array('approved' => 1, 'userid' => $u1->id));
 432          $e2a2 = $gg->create_content($g2, array('approved' => 1, 'userid' => $u1->id));
 433  
 434          $cat1a = $gg->create_category($g1, array('name' => 'Fish'), array($e1a1, $e1a2, $e1a3));
 435          $cat1b = $gg->create_category($g1, array('name' => 'Cat'), array($e1b1, $e1b2));
 436          $cat1c = $gg->create_category($g1, array('name' => 'Zebra'), array($e1b1));   // Entry $e1b1 is in two categories.
 437          $cat2a = $gg->create_category($g2, array(), array($e2a1, $e2a2));
 438  
 439          $this->setAdminUser();
 440  
 441          // Browse one category.
 442          $return = mod_glossary_external::get_entries_by_category($g1->id, $cat1a->id, 0, 20, array());
 443          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_category_returns(), $return);
 444          $this->assertCount(3, $return['entries']);
 445          $this->assertEquals(3, $return['count']);
 446          $this->assertEquals($e1a1->id, $return['entries'][0]['id']);
 447          $this->assertEquals($e1a2->id, $return['entries'][1]['id']);
 448          $this->assertEquals($e1a3->id, $return['entries'][2]['id']);
 449  
 450          // Browse all categories.
 451          $return = mod_glossary_external::get_entries_by_category($g1->id, GLOSSARY_SHOW_ALL_CATEGORIES, 0, 20, array());
 452          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_category_returns(), $return);
 453          $this->assertCount(5, $return['entries']);
 454          $this->assertEquals(5, $return['count']);
 455          $this->assertEquals($e1b1->id, $return['entries'][0]['id']);
 456          $this->assertEquals($e1a1->id, $return['entries'][1]['id']);
 457          $this->assertEquals($e1a2->id, $return['entries'][2]['id']);
 458          $this->assertEquals($e1a3->id, $return['entries'][3]['id']);
 459          $this->assertEquals($e1b1->id, $return['entries'][4]['id']);
 460  
 461          // Browse uncategorised.
 462          $return = mod_glossary_external::get_entries_by_category($g1->id, GLOSSARY_SHOW_NOT_CATEGORISED, 0, 20, array());
 463          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_category_returns(), $return);
 464          $this->assertCount(1, $return['entries']);
 465          $this->assertEquals(1, $return['count']);
 466          $this->assertEquals($e1x1->id, $return['entries'][0]['id']);
 467  
 468          // Including to approve.
 469          $return = mod_glossary_external::get_entries_by_category($g1->id, $cat1b->id, 0, 20,
 470              array('includenotapproved' => true));
 471          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_category_returns(), $return);
 472          $this->assertCount(2, $return['entries']);
 473          $this->assertEquals(2, $return['count']);
 474          $this->assertEquals($e1b1->id, $return['entries'][0]['id']);
 475          $this->assertEquals($e1b2->id, $return['entries'][1]['id']);
 476  
 477          // Using limit.
 478          $return = mod_glossary_external::get_entries_by_category($g1->id, GLOSSARY_SHOW_ALL_CATEGORIES, 0, 3,
 479              array('includenotapproved' => true));
 480          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_category_returns(), $return);
 481          $this->assertCount(3, $return['entries']);
 482          $this->assertEquals(6, $return['count']);
 483          $this->assertEquals($e1b1->id, $return['entries'][0]['id']);
 484          $this->assertEquals($e1b2->id, $return['entries'][1]['id']);
 485          $this->assertEquals($e1a1->id, $return['entries'][2]['id']);
 486          $return = mod_glossary_external::get_entries_by_category($g1->id, GLOSSARY_SHOW_ALL_CATEGORIES, 3, 2,
 487              array('includenotapproved' => true));
 488          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_category_returns(), $return);
 489          $this->assertCount(2, $return['entries']);
 490          $this->assertEquals(6, $return['count']);
 491          $this->assertEquals($e1a2->id, $return['entries'][0]['id']);
 492          $this->assertEquals($e1a3->id, $return['entries'][1]['id']);
 493      }
 494  
 495      public function test_get_authors() {
 496          $this->resetAfterTest(true);
 497  
 498          $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 499          $c1 = $this->getDataGenerator()->create_course();
 500          $g1 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 501          $g2 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 502  
 503          $u1 = $this->getDataGenerator()->create_user(array('lastname' => 'Upsilon'));
 504          $u2 = $this->getDataGenerator()->create_user(array('lastname' => 'Alpha'));
 505          $u3 = $this->getDataGenerator()->create_user(array('lastname' => 'Omega'));
 506  
 507          $ctx = context_module::instance($g1->cmid);
 508  
 509          $e1a = $gg->create_content($g1, array('userid' => $u1->id, 'approved' => 1));
 510          $e1b = $gg->create_content($g1, array('userid' => $u1->id, 'approved' => 1));
 511          $e1c = $gg->create_content($g1, array('userid' => $u1->id, 'approved' => 1));
 512          $e2a = $gg->create_content($g1, array('userid' => $u2->id, 'approved' => 1));
 513          $e3a = $gg->create_content($g1, array('userid' => $u3->id, 'approved' => 0));
 514  
 515          $this->setAdminUser();
 516  
 517          // Simple request.
 518          $return = mod_glossary_external::get_authors($g1->id, 0, 20, array());
 519          $return = external_api::clean_returnvalue(mod_glossary_external::get_authors_returns(), $return);
 520          $this->assertCount(2, $return['authors']);
 521          $this->assertEquals(2, $return['count']);
 522          $this->assertEquals($u2->id, $return['authors'][0]['id']);
 523          $this->assertEquals($u1->id, $return['authors'][1]['id']);
 524  
 525          // Include users with entries pending approval.
 526          $return = mod_glossary_external::get_authors($g1->id, 0, 20, array('includenotapproved' => true));
 527          $return = external_api::clean_returnvalue(mod_glossary_external::get_authors_returns(), $return);
 528          $this->assertCount(3, $return['authors']);
 529          $this->assertEquals(3, $return['count']);
 530          $this->assertEquals($u2->id, $return['authors'][0]['id']);
 531          $this->assertEquals($u3->id, $return['authors'][1]['id']);
 532          $this->assertEquals($u1->id, $return['authors'][2]['id']);
 533  
 534          // Pagination.
 535          $return = mod_glossary_external::get_authors($g1->id, 1, 1, array('includenotapproved' => true));
 536          $return = external_api::clean_returnvalue(mod_glossary_external::get_authors_returns(), $return);
 537          $this->assertCount(1, $return['authors']);
 538          $this->assertEquals(3, $return['count']);
 539          $this->assertEquals($u3->id, $return['authors'][0]['id']);
 540      }
 541  
 542      public function test_get_entries_by_author() {
 543          $this->resetAfterTest(true);
 544  
 545          // Generate all the things.
 546          $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 547          $c1 = $this->getDataGenerator()->create_course();
 548          $g1 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id, 'displayformat' => 'entrylist'));
 549          $g2 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id, 'displayformat' => 'entrylist'));
 550          $u1 = $this->getDataGenerator()->create_user(array('lastname' => 'Upsilon', 'firstname' => 'Zac'));
 551          $u2 = $this->getDataGenerator()->create_user(array('lastname' => 'Ultra', 'firstname' => '1337'));
 552          $u3 = $this->getDataGenerator()->create_user(array('lastname' => 'Alpha', 'firstname' => 'Omega'));
 553          $u4 = $this->getDataGenerator()->create_user(array('lastname' => '0-day', 'firstname' => 'Zoe'));
 554          $ctx = context_module::instance($g1->cmid);
 555          $this->getDataGenerator()->enrol_user($u1->id, $c1->id);
 556  
 557          $e1a1 = $gg->create_content($g1, array('approved' => 1, 'userid' => $u1->id));
 558          $e1a2 = $gg->create_content($g1, array('approved' => 1, 'userid' => $u1->id));
 559          $e1a3 = $gg->create_content($g1, array('approved' => 1, 'userid' => $u1->id));
 560          $e1b1 = $gg->create_content($g1, array('approved' => 0, 'userid' => $u2->id));
 561          $e1b2 = $gg->create_content($g1, array('approved' => 1, 'userid' => $u2->id));
 562          $e1c1 = $gg->create_content($g1, array('approved' => 1, 'userid' => $u3->id));
 563          $e1d1 = $gg->create_content($g1, array('approved' => 1, 'userid' => $u4->id));
 564          $e2a = $gg->create_content($g2, array('approved' => 1, 'userid' => $u1->id));
 565  
 566          $this->setUser($u1);
 567  
 568          // Requesting a single letter.
 569          $return = mod_glossary_external::get_entries_by_author($g1->id, 'u', 'LASTNAME', 'ASC', 0, 20, array());
 570          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_returns(), $return);
 571          $this->assertCount(4, $return['entries']);
 572          $this->assertEquals(4, $return['count']);
 573          $this->assertEquals($e1b2->id, $return['entries'][0]['id']);
 574          $this->assertEquals($e1a1->id, $return['entries'][1]['id']);
 575          $this->assertEquals($e1a2->id, $return['entries'][2]['id']);
 576          $this->assertEquals($e1a3->id, $return['entries'][3]['id']);
 577  
 578          // Requesting special letters.
 579          $return = mod_glossary_external::get_entries_by_author($g1->id, 'SPECIAL', 'LASTNAME', 'ASC', 0, 20, array());
 580          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_returns(), $return);
 581          $this->assertCount(1, $return['entries']);
 582          $this->assertEquals(1, $return['count']);
 583          $this->assertEquals($e1d1->id, $return['entries'][0]['id']);
 584  
 585          // Requesting with limit.
 586          $return = mod_glossary_external::get_entries_by_author($g1->id, 'ALL', 'LASTNAME', 'ASC', 0, 1, array());
 587          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_returns(), $return);
 588          $this->assertCount(1, $return['entries']);
 589          $this->assertEquals(6, $return['count']);
 590          $this->assertEquals($e1d1->id, $return['entries'][0]['id']);
 591          $return = mod_glossary_external::get_entries_by_author($g1->id, 'ALL', 'LASTNAME', 'ASC', 1, 2, array());
 592          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_returns(), $return);
 593          $this->assertCount(2, $return['entries']);
 594          $this->assertEquals(6, $return['count']);
 595          $this->assertEquals($e1c1->id, $return['entries'][0]['id']);
 596          $this->assertEquals($e1b2->id, $return['entries'][1]['id']);
 597  
 598          // Including non-approved.
 599          $this->setAdminUser();
 600          $return = mod_glossary_external::get_entries_by_author($g1->id, 'ALL', 'LASTNAME', 'ASC', 0, 20,
 601              array('includenotapproved' => true));
 602          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_returns(), $return);
 603          $this->assertCount(7, $return['entries']);
 604          $this->assertEquals(7, $return['count']);
 605          $this->assertEquals($e1d1->id, $return['entries'][0]['id']);
 606          $this->assertEquals($e1c1->id, $return['entries'][1]['id']);
 607          $this->assertEquals($e1b1->id, $return['entries'][2]['id']);
 608          $this->assertEquals($e1b2->id, $return['entries'][3]['id']);
 609          $this->assertEquals($e1a1->id, $return['entries'][4]['id']);
 610          $this->assertEquals($e1a2->id, $return['entries'][5]['id']);
 611          $this->assertEquals($e1a3->id, $return['entries'][6]['id']);
 612  
 613          // Changing order.
 614          $return = mod_glossary_external::get_entries_by_author($g1->id, 'ALL', 'LASTNAME', 'DESC', 0, 1, array());
 615          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_returns(), $return);
 616          $this->assertCount(1, $return['entries']);
 617          $this->assertEquals(6, $return['count']);
 618          $this->assertEquals($e1a1->id, $return['entries'][0]['id']);
 619  
 620          // Sorting by firstname.
 621          $return = mod_glossary_external::get_entries_by_author($g1->id, 'ALL', 'FIRSTNAME', 'ASC', 0, 1, array());
 622          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_returns(), $return);
 623          $this->assertCount(1, $return['entries']);
 624          $this->assertEquals(6, $return['count']);
 625          $this->assertEquals($e1b2->id, $return['entries'][0]['id']);
 626  
 627          // Sorting by firstname descending.
 628          $return = mod_glossary_external::get_entries_by_author($g1->id, 'ALL', 'FIRSTNAME', 'DESC', 0, 1, array());
 629          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_returns(), $return);
 630          $this->assertCount(1, $return['entries']);
 631          $this->assertEquals(6, $return['count']);
 632          $this->assertEquals($e1d1->id, $return['entries'][0]['id']);
 633  
 634          // Filtering by firstname descending.
 635          $return = mod_glossary_external::get_entries_by_author($g1->id, 'z', 'FIRSTNAME', 'DESC', 0, 20, array());
 636          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_returns(), $return);
 637          $this->assertCount(4, $return['entries']);
 638          $this->assertEquals(4, $return['count']);
 639          $this->assertEquals($e1d1->id, $return['entries'][0]['id']);
 640          $this->assertEquals($e1a1->id, $return['entries'][1]['id']);
 641          $this->assertEquals($e1a2->id, $return['entries'][2]['id']);
 642          $this->assertEquals($e1a3->id, $return['entries'][3]['id']);
 643  
 644          // Test with a deleted user.
 645          delete_user($u2);
 646          $return = mod_glossary_external::get_entries_by_author($g1->id, 'u', 'LASTNAME', 'ASC', 0, 20, array());
 647          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_returns(), $return);
 648          $this->assertCount(4, $return['entries']);
 649          $this->assertEquals(4, $return['count']);
 650          $this->assertEquals($e1b2->id, $return['entries'][0]['id']);
 651          $this->assertEquals($e1a1->id, $return['entries'][1]['id']);
 652          $this->assertEquals($e1a2->id, $return['entries'][2]['id']);
 653          $this->assertEquals($e1a3->id, $return['entries'][3]['id']);
 654      }
 655  
 656      public function test_get_entries_by_author_id() {
 657          $this->resetAfterTest(true);
 658  
 659          // Generate all the things.
 660          $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 661          $c1 = $this->getDataGenerator()->create_course();
 662          $g1 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id, 'displayformat' => 'entrylist'));
 663          $g2 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id, 'displayformat' => 'entrylist'));
 664          $u1 = $this->getDataGenerator()->create_user(array('lastname' => 'Upsilon', 'firstname' => 'Zac'));
 665          $u2 = $this->getDataGenerator()->create_user(array('lastname' => 'Ultra', 'firstname' => '1337'));
 666          $u3 = $this->getDataGenerator()->create_user(array('lastname' => 'Alpha', 'firstname' => 'Omega'));
 667          $u4 = $this->getDataGenerator()->create_user(array('lastname' => '0-day', 'firstname' => 'Zoe'));
 668          $ctx = context_module::instance($g1->cmid);
 669          $this->getDataGenerator()->enrol_user($u1->id, $c1->id);
 670  
 671          $e1a1 = $gg->create_content($g1, array('approved' => 1, 'userid' => $u1->id, 'concept' => 'Zoom',
 672              'timecreated' => 3600, 'timemodified' => time() - 3600));
 673          $e1a2 = $gg->create_content($g1, array('approved' => 1, 'userid' => $u1->id, 'concept' => 'Alpha'));
 674          $e1a3 = $gg->create_content($g1, array('approved' => 1, 'userid' => $u1->id, 'concept' => 'Dog',
 675              'timecreated' => 1, 'timemodified' => time() - 1800));
 676          $e1a4 = $gg->create_content($g1, array('approved' => 0, 'userid' => $u1->id, 'concept' => 'Bird'));
 677          $e1b1 = $gg->create_content($g1, array('approved' => 0, 'userid' => $u2->id));
 678          $e2a = $gg->create_content($g2, array('approved' => 1, 'userid' => $u1->id));
 679  
 680          $this->setAdminUser();
 681  
 682          // Standard request.
 683          $return = mod_glossary_external::get_entries_by_author_id($g1->id, $u1->id, 'CONCEPT', 'ASC', 0, 20, array());
 684          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_id_returns(), $return);
 685          $this->assertCount(3, $return['entries']);
 686          $this->assertEquals(3, $return['count']);
 687          $this->assertEquals($e1a2->id, $return['entries'][0]['id']);
 688          $this->assertEquals($e1a3->id, $return['entries'][1]['id']);
 689          $this->assertEquals($e1a1->id, $return['entries'][2]['id']);
 690  
 691          // Standard request descending.
 692          $return = mod_glossary_external::get_entries_by_author_id($g1->id, $u1->id, 'CONCEPT', 'DESC', 0, 20, array());
 693          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_id_returns(), $return);
 694          $this->assertCount(3, $return['entries']);
 695          $this->assertEquals(3, $return['count']);
 696          $this->assertEquals($e1a1->id, $return['entries'][0]['id']);
 697          $this->assertEquals($e1a3->id, $return['entries'][1]['id']);
 698          $this->assertEquals($e1a2->id, $return['entries'][2]['id']);
 699  
 700          // Requesting ordering by time created.
 701          $return = mod_glossary_external::get_entries_by_author_id($g1->id, $u1->id, 'CREATION', 'ASC', 0, 20, array());
 702          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_id_returns(), $return);
 703          $this->assertCount(3, $return['entries']);
 704          $this->assertEquals(3, $return['count']);
 705          $this->assertEquals($e1a3->id, $return['entries'][0]['id']);
 706          $this->assertEquals($e1a1->id, $return['entries'][1]['id']);
 707          $this->assertEquals($e1a2->id, $return['entries'][2]['id']);
 708  
 709          // Requesting ordering by time created descending.
 710          $return = mod_glossary_external::get_entries_by_author_id($g1->id, $u1->id, 'CREATION', 'DESC', 0, 20, array());
 711          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_id_returns(), $return);
 712          $this->assertCount(3, $return['entries']);
 713          $this->assertEquals(3, $return['count']);
 714          $this->assertEquals($e1a2->id, $return['entries'][0]['id']);
 715          $this->assertEquals($e1a1->id, $return['entries'][1]['id']);
 716          $this->assertEquals($e1a3->id, $return['entries'][2]['id']);
 717  
 718          // Requesting ordering by time modified.
 719          $return = mod_glossary_external::get_entries_by_author_id($g1->id, $u1->id, 'UPDATE', 'ASC', 0, 20, array());
 720          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_id_returns(), $return);
 721          $this->assertCount(3, $return['entries']);
 722          $this->assertEquals(3, $return['count']);
 723          $this->assertEquals($e1a1->id, $return['entries'][0]['id']);
 724          $this->assertEquals($e1a3->id, $return['entries'][1]['id']);
 725          $this->assertEquals($e1a2->id, $return['entries'][2]['id']);
 726  
 727          // Requesting ordering by time modified descending.
 728          $return = mod_glossary_external::get_entries_by_author_id($g1->id, $u1->id, 'UPDATE', 'DESC', 0, 20, array());
 729          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_id_returns(), $return);
 730          $this->assertCount(3, $return['entries']);
 731          $this->assertEquals(3, $return['count']);
 732          $this->assertEquals($e1a2->id, $return['entries'][0]['id']);
 733          $this->assertEquals($e1a3->id, $return['entries'][1]['id']);
 734          $this->assertEquals($e1a1->id, $return['entries'][2]['id']);
 735  
 736          // Including non approved.
 737          $return = mod_glossary_external::get_entries_by_author_id($g1->id, $u1->id, 'CONCEPT', 'ASC', 0, 20,
 738              array('includenotapproved' => true));
 739          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_id_returns(), $return);
 740          $this->assertCount(4, $return['entries']);
 741          $this->assertEquals(4, $return['count']);
 742          $this->assertEquals($e1a2->id, $return['entries'][0]['id']);
 743          $this->assertEquals($e1a4->id, $return['entries'][1]['id']);
 744          $this->assertEquals($e1a3->id, $return['entries'][2]['id']);
 745          $this->assertEquals($e1a1->id, $return['entries'][3]['id']);
 746  
 747          // Pagination.
 748          $return = mod_glossary_external::get_entries_by_author_id($g1->id, $u1->id, 'CONCEPT', 'ASC', 0, 2,
 749              array('includenotapproved' => true));
 750          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_id_returns(), $return);
 751          $this->assertCount(2, $return['entries']);
 752          $this->assertEquals(4, $return['count']);
 753          $this->assertEquals($e1a2->id, $return['entries'][0]['id']);
 754          $this->assertEquals($e1a4->id, $return['entries'][1]['id']);
 755          $return = mod_glossary_external::get_entries_by_author_id($g1->id, $u1->id, 'CONCEPT', 'ASC', 1, 2,
 756              array('includenotapproved' => true));
 757          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_author_id_returns(), $return);
 758          $this->assertCount(2, $return['entries']);
 759          $this->assertEquals(4, $return['count']);
 760          $this->assertEquals($e1a4->id, $return['entries'][0]['id']);
 761          $this->assertEquals($e1a3->id, $return['entries'][1]['id']);
 762      }
 763  
 764      public function test_get_entries_by_search() {
 765          $this->resetAfterTest(true);
 766  
 767          // Generate all the things.
 768          $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 769          $c1 = $this->getDataGenerator()->create_course();
 770          $g1 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 771          $g2 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 772          $u1 = $this->getDataGenerator()->create_user();
 773          $ctx = context_module::instance($g1->cmid);
 774          $this->getDataGenerator()->enrol_user($u1->id, $c1->id);
 775          $this->setUser($u1);
 776  
 777          $e1 = $gg->create_content($g1, array('approved' => 1, 'concept' => 'House', 'timecreated' => time() + 3600));
 778          $e2 = $gg->create_content($g1, array('approved' => 1, 'concept' => 'Mouse', 'timemodified' => 1));
 779          $e3 = $gg->create_content($g1, array('approved' => 1, 'concept' => 'Hero'));
 780          $e4 = $gg->create_content($g1, array('approved' => 0, 'concept' => 'Toulouse'));
 781          $e5 = $gg->create_content($g1, array('approved' => 1, 'definition' => 'Heroes', 'concept' => 'Abcd'));
 782          $e6 = $gg->create_content($g1, array('approved' => 0, 'definition' => 'When used for Heroes'));
 783          $e7 = $gg->create_content($g1, array('approved' => 1, 'timecreated' => 1, 'timemodified' => time() + 3600,
 784              'concept' => 'Z'), array('Couscous'));
 785          $e8 = $gg->create_content($g1, array('approved' => 0), array('Heroes'));
 786          $e9 = $gg->create_content($g2, array('approved' => 0));
 787  
 788          $this->setAdminUser();
 789  
 790          // Test simple query.
 791          $query = 'hero';
 792          $return = mod_glossary_external::get_entries_by_search($g1->id, $query, false, 'CONCEPT', 'ASC', 0, 20, array());
 793          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_search_returns(), $return);
 794          $this->assertCount(1, $return['entries']);
 795          $this->assertEquals(1, $return['count']);
 796          $this->assertEquals($e3->id, $return['entries'][0]['id']);
 797  
 798          // Enabling full search.
 799          $query = 'hero';
 800          $return = mod_glossary_external::get_entries_by_search($g1->id, $query, true, 'CONCEPT', 'ASC', 0, 20, array());
 801          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_search_returns(), $return);
 802          $this->assertCount(2, $return['entries']);
 803          $this->assertEquals(2, $return['count']);
 804          $this->assertEquals($e5->id, $return['entries'][0]['id']);
 805          $this->assertEquals($e3->id, $return['entries'][1]['id']);
 806  
 807          // Concept descending.
 808          $query = 'hero';
 809          $return = mod_glossary_external::get_entries_by_search($g1->id, $query, true, 'CONCEPT', 'DESC', 0, 20, array());
 810          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_search_returns(), $return);
 811          $this->assertCount(2, $return['entries']);
 812          $this->assertEquals(2, $return['count']);
 813          $this->assertEquals($e3->id, $return['entries'][0]['id']);
 814          $this->assertEquals($e5->id, $return['entries'][1]['id']);
 815  
 816          // Search on alias.
 817          $query = 'couscous';
 818          $return = mod_glossary_external::get_entries_by_search($g1->id, $query, false, 'CONCEPT', 'ASC', 0, 20, array());
 819          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_search_returns(), $return);
 820          $this->assertCount(1, $return['entries']);
 821          $this->assertEquals(1, $return['count']);
 822          $this->assertEquals($e7->id, $return['entries'][0]['id']);
 823          $return = mod_glossary_external::get_entries_by_search($g1->id, $query, true, 'CONCEPT', 'ASC', 0, 20, array());
 824          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_search_returns(), $return);
 825          $this->assertCount(1, $return['entries']);
 826          $this->assertEquals(1, $return['count']);
 827          $this->assertEquals($e7->id, $return['entries'][0]['id']);
 828  
 829          // Pagination and ordering on created date.
 830          $query = 'ou';
 831          $return = mod_glossary_external::get_entries_by_search($g1->id, $query, false, 'CREATION', 'ASC', 0, 1, array());
 832          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_search_returns(), $return);
 833          $this->assertCount(1, $return['entries']);
 834          $this->assertEquals(3, $return['count']);
 835          $this->assertEquals($e7->id, $return['entries'][0]['id']);
 836          $return = mod_glossary_external::get_entries_by_search($g1->id, $query, false, 'CREATION', 'DESC', 0, 1, array());
 837          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_search_returns(), $return);
 838          $this->assertCount(1, $return['entries']);
 839          $this->assertEquals(3, $return['count']);
 840          $this->assertEquals($e1->id, $return['entries'][0]['id']);
 841  
 842          // Ordering on updated date.
 843          $query = 'ou';
 844          $return = mod_glossary_external::get_entries_by_search($g1->id, $query, false, 'UPDATE', 'ASC', 0, 1, array());
 845          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_search_returns(), $return);
 846          $this->assertCount(1, $return['entries']);
 847          $this->assertEquals(3, $return['count']);
 848          $this->assertEquals($e2->id, $return['entries'][0]['id']);
 849          $return = mod_glossary_external::get_entries_by_search($g1->id, $query, false, 'UPDATE', 'DESC', 0, 1, array());
 850          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_search_returns(), $return);
 851          $this->assertCount(1, $return['entries']);
 852          $this->assertEquals(3, $return['count']);
 853          $this->assertEquals($e7->id, $return['entries'][0]['id']);
 854  
 855          // Including not approved.
 856          $query = 'ou';
 857          $return = mod_glossary_external::get_entries_by_search($g1->id, $query, false, 'CONCEPT', 'ASC', 0, 20,
 858              array('includenotapproved' => true));
 859          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_search_returns(), $return);
 860          $this->assertCount(4, $return['entries']);
 861          $this->assertEquals(4, $return['count']);
 862          $this->assertEquals($e1->id, $return['entries'][0]['id']);
 863          $this->assertEquals($e2->id, $return['entries'][1]['id']);
 864          $this->assertEquals($e4->id, $return['entries'][2]['id']);
 865          $this->assertEquals($e7->id, $return['entries'][3]['id']);
 866  
 867          // Advanced query string.
 868          $query = '+Heroes -Abcd';
 869          $return = mod_glossary_external::get_entries_by_search($g1->id, $query, true, 'CONCEPT', 'ASC', 0, 20,
 870              array('includenotapproved' => true));
 871          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_search_returns(), $return);
 872          $this->assertCount(2, $return['entries']);
 873          $this->assertEquals(2, $return['count']);
 874          $this->assertEquals($e6->id, $return['entries'][0]['id']);
 875          $this->assertEquals($e8->id, $return['entries'][1]['id']);
 876      }
 877  
 878      public function test_get_entries_by_term() {
 879          $this->resetAfterTest(true);
 880  
 881          // Generate all the things.
 882          $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 883          $c1 = $this->getDataGenerator()->create_course();
 884          $g1 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 885          $g2 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 886          $u1 = $this->getDataGenerator()->create_user();
 887          $ctx = context_module::instance($g1->cmid);
 888          $this->getDataGenerator()->enrol_user($u1->id, $c1->id);
 889  
 890          $this->setAdminUser();
 891  
 892          $e1 = $gg->create_content($g1, array('userid' => $u1->id, 'approved' => 1, 'concept' => 'cat'));
 893          $e2 = $gg->create_content($g1, array('userid' => $u1->id, 'approved' => 1), array('cat', 'dog'));
 894          $e3 = $gg->create_content($g1, array('userid' => $u1->id, 'approved' => 1), array('dog'));
 895          $e4 = $gg->create_content($g1, array('userid' => $u1->id, 'approved' => 0, 'concept' => 'dog'));
 896          $e5 = $gg->create_content($g2, array('userid' => $u1->id, 'approved' => 1, 'concept' => 'dog'), array('cat'));
 897  
 898          // Search concept + alias.
 899          $return = mod_glossary_external::get_entries_by_term($g1->id, 'cat', 0, 20, array('includenotapproved' => false));
 900          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_term_returns(), $return);
 901          $this->assertCount(2, $return['entries']);
 902          $this->assertEquals(2, $return['count']);
 903          // Compare ids, ignore ordering of array, using canonicalize parameter of assertEquals.
 904          $expected = array($e1->id, $e2->id);
 905          $actual = array($return['entries'][0]['id'], $return['entries'][1]['id']);
 906          $this->assertEquals($expected, $actual, '', 0.0, 10, true);
 907  
 908          // Search alias.
 909          $return = mod_glossary_external::get_entries_by_term($g1->id, 'dog', 0, 20, array('includenotapproved' => false));
 910          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_term_returns(), $return);
 911  
 912          $this->assertCount(2, $return['entries']);
 913          $this->assertEquals(2, $return['count']);
 914          // Compare ids, ignore ordering of array, using canonicalize parameter of assertEquals.
 915          $expected = array($e2->id, $e3->id);
 916          $actual = array($return['entries'][0]['id'], $return['entries'][1]['id']);
 917          $this->assertEquals($expected, $actual, '', 0.0, 10, true);
 918  
 919          // Search including not approved.
 920          $return = mod_glossary_external::get_entries_by_term($g1->id, 'dog', 0, 20, array('includenotapproved' => true));
 921          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_term_returns(), $return);
 922          $this->assertCount(3, $return['entries']);
 923          $this->assertEquals(3, $return['count']);
 924          // Compare ids, ignore ordering of array, using canonicalize parameter of assertEquals.
 925          $expected = array($e4->id, $e2->id, $e3->id);
 926          $actual = array($return['entries'][0]['id'], $return['entries'][1]['id'], $return['entries'][2]['id']);
 927          $this->assertEquals($expected, $actual, '', 0.0, 10, true);
 928  
 929          // Pagination.
 930          $return = mod_glossary_external::get_entries_by_term($g1->id, 'dog', 0, 1, array('includenotapproved' => true));
 931          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_term_returns(), $return);
 932          $this->assertCount(1, $return['entries']);
 933          // We don't compare the returned entry id because it may be different depending on the DBMS,
 934          // for example, Postgres does a random sorting in this case.
 935          $this->assertEquals(3, $return['count']);
 936          $return = mod_glossary_external::get_entries_by_term($g1->id, 'dog', 1, 1, array('includenotapproved' => true));
 937          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_by_term_returns(), $return);
 938          $this->assertCount(1, $return['entries']);
 939          $this->assertEquals(3, $return['count']);
 940      }
 941  
 942      public function test_get_entries_to_approve() {
 943          $this->resetAfterTest(true);
 944  
 945          // Generate all the things.
 946          $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
 947          $c1 = $this->getDataGenerator()->create_course();
 948          $g1 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 949          $g2 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
 950          $u1 = $this->getDataGenerator()->create_user();
 951          $ctx = context_module::instance($g1->cmid);
 952          $this->getDataGenerator()->enrol_user($u1->id, $c1->id);
 953  
 954          $e1a = $gg->create_content($g1, array('approved' => 0, 'concept' => 'Bob', 'userid' => $u1->id,
 955              'timecreated' => time() + 3600));
 956          $e1b = $gg->create_content($g1, array('approved' => 0, 'concept' => 'Jane', 'userid' => $u1->id, 'timecreated' => 1));
 957          $e1c = $gg->create_content($g1, array('approved' => 0, 'concept' => 'Alice', 'userid' => $u1->id, 'timemodified' => 1));
 958          $e1d = $gg->create_content($g1, array('approved' => 0, 'concept' => '0-day', 'userid' => $u1->id,
 959              'timemodified' => time() + 3600));
 960          $e1e = $gg->create_content($g1, array('approved' => 1, 'concept' => '1-day', 'userid' => $u1->id));
 961          $e2a = $gg->create_content($g2);
 962  
 963          $this->setAdminUser(true);
 964  
 965          // Simple listing.
 966          $return = mod_glossary_external::get_entries_to_approve($g1->id, 'ALL', 'CONCEPT', 'ASC', 0, 20);
 967          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_to_approve_returns(), $return);
 968          $this->assertCount(4, $return['entries']);
 969          $this->assertEquals(4, $return['count']);
 970          $this->assertEquals($e1d->id, $return['entries'][0]['id']);
 971          $this->assertEquals($e1c->id, $return['entries'][1]['id']);
 972          $this->assertEquals($e1a->id, $return['entries'][2]['id']);
 973          $this->assertEquals($e1b->id, $return['entries'][3]['id']);
 974  
 975          // Revert ordering of concept.
 976          $return = mod_glossary_external::get_entries_to_approve($g1->id, 'ALL', 'CONCEPT', 'DESC', 0, 20);
 977          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_to_approve_returns(), $return);
 978          $this->assertCount(4, $return['entries']);
 979          $this->assertEquals(4, $return['count']);
 980          $this->assertEquals($e1b->id, $return['entries'][0]['id']);
 981          $this->assertEquals($e1a->id, $return['entries'][1]['id']);
 982          $this->assertEquals($e1c->id, $return['entries'][2]['id']);
 983          $this->assertEquals($e1d->id, $return['entries'][3]['id']);
 984  
 985          // Filtering by letter.
 986          $return = mod_glossary_external::get_entries_to_approve($g1->id, 'a', 'CONCEPT', 'ASC', 0, 20);
 987          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_to_approve_returns(), $return);
 988          $this->assertCount(1, $return['entries']);
 989          $this->assertEquals(1, $return['count']);
 990          $this->assertEquals($e1c->id, $return['entries'][0]['id']);
 991  
 992          // Filtering by special.
 993          $return = mod_glossary_external::get_entries_to_approve($g1->id, 'SPECIAL', 'CONCEPT', 'ASC', 0, 20);
 994          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_to_approve_returns(), $return);
 995          $this->assertCount(1, $return['entries']);
 996          $this->assertEquals(1, $return['count']);
 997          $this->assertEquals($e1d->id, $return['entries'][0]['id']);
 998  
 999          // Pagination.
1000          $return = mod_glossary_external::get_entries_to_approve($g1->id, 'ALL', 'CONCEPT', 'ASC', 0, 2);
1001          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_to_approve_returns(), $return);
1002          $this->assertCount(2, $return['entries']);
1003          $this->assertEquals(4, $return['count']);
1004          $this->assertEquals($e1d->id, $return['entries'][0]['id']);
1005          $this->assertEquals($e1c->id, $return['entries'][1]['id']);
1006          $return = mod_glossary_external::get_entries_to_approve($g1->id, 'ALL', 'CONCEPT', 'ASC', 1, 2);
1007          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_to_approve_returns(), $return);
1008          $this->assertCount(2, $return['entries']);
1009          $this->assertEquals(4, $return['count']);
1010          $this->assertEquals($e1c->id, $return['entries'][0]['id']);
1011          $this->assertEquals($e1a->id, $return['entries'][1]['id']);
1012  
1013          // Ordering by creation date.
1014          $return = mod_glossary_external::get_entries_to_approve($g1->id, 'ALL', 'CREATION', 'ASC', 0, 1);
1015          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_to_approve_returns(), $return);
1016          $this->assertCount(1, $return['entries']);
1017          $this->assertEquals(4, $return['count']);
1018          $this->assertEquals($e1b->id, $return['entries'][0]['id']);
1019  
1020          // Ordering by creation date desc.
1021          $return = mod_glossary_external::get_entries_to_approve($g1->id, 'ALL', 'CREATION', 'DESC', 0, 1);
1022          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_to_approve_returns(), $return);
1023          $this->assertCount(1, $return['entries']);
1024          $this->assertEquals(4, $return['count']);
1025          $this->assertEquals($e1a->id, $return['entries'][0]['id']);
1026  
1027          // Ordering by update date.
1028          $return = mod_glossary_external::get_entries_to_approve($g1->id, 'ALL', 'UPDATE', 'ASC', 0, 1);
1029          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_to_approve_returns(), $return);
1030          $this->assertCount(1, $return['entries']);
1031          $this->assertEquals(4, $return['count']);
1032          $this->assertEquals($e1c->id, $return['entries'][0]['id']);
1033  
1034          // Ordering by update date desc.
1035          $return = mod_glossary_external::get_entries_to_approve($g1->id, 'ALL', 'UPDATE', 'DESC', 0, 1);
1036          $return = external_api::clean_returnvalue(mod_glossary_external::get_entries_to_approve_returns(), $return);
1037          $this->assertCount(1, $return['entries']);
1038          $this->assertEquals(4, $return['count']);
1039          $this->assertEquals($e1d->id, $return['entries'][0]['id']);
1040  
1041          // Permissions are checked.
1042          $this->setUser($u1);
1043          $this->expectException('required_capability_exception');
1044          mod_glossary_external::get_entries_to_approve($g1->id, 'ALL', 'CONCEPT', 'ASC', 0, 1);
1045          $this->fail('Do not test anything else after this.');
1046      }
1047  
1048      public function test_get_entry_by_id() {
1049          $this->resetAfterTest(true);
1050  
1051          // Generate all the things.
1052          $gg = $this->getDataGenerator()->get_plugin_generator('mod_glossary');
1053          $c1 = $this->getDataGenerator()->create_course();
1054          $c2 = $this->getDataGenerator()->create_course();
1055          $g1 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id));
1056          $g2 = $this->getDataGenerator()->create_module('glossary', array('course' => $c1->id, 'visible' => 0));
1057          $u1 = $this->getDataGenerator()->create_user();
1058          $u2 = $this->getDataGenerator()->create_user();
1059          $ctx = context_module::instance($g1->cmid);
1060          $this->getDataGenerator()->enrol_user($u1->id, $c1->id);
1061  
1062          $e1 = $gg->create_content($g1, array('approved' => 1, 'userid' => $u1->id));
1063          $e2 = $gg->create_content($g1, array('approved' => 0, 'userid' => $u1->id));
1064          $e3 = $gg->create_content($g1, array('approved' => 0, 'userid' => $u2->id));
1065          $e4 = $gg->create_content($g2, array('approved' => 1));
1066  
1067          $this->setUser($u1);
1068          $return = mod_glossary_external::get_entry_by_id($e1->id);
1069          $return = external_api::clean_returnvalue(mod_glossary_external::get_entry_by_id_returns(), $return);
1070          $this->assertEquals($e1->id, $return['entry']['id']);
1071  
1072          $return = mod_glossary_external::get_entry_by_id($e2->id);
1073          $return = external_api::clean_returnvalue(mod_glossary_external::get_entry_by_id_returns(), $return);
1074          $this->assertEquals($e2->id, $return['entry']['id']);
1075  
1076          try {
1077              $return = mod_glossary_external::get_entry_by_id($e3->id);
1078              $this->fail('Cannot view unapproved entries of others.');
1079          } catch (invalid_parameter_exception $e) {
1080              // All good.
1081          }
1082  
1083          try {
1084              $return = mod_glossary_external::get_entry_by_id($e4->id);
1085              $this->fail('Cannot view entries from another course.');
1086          } catch (require_login_exception $e) {
1087              // All good.
1088          }
1089  
1090          // An admin can be other's entries to be approved.
1091          $this->setAdminUser();
1092          $return = mod_glossary_external::get_entry_by_id($e3->id);
1093          $return = external_api::clean_returnvalue(mod_glossary_external::get_entry_by_id_returns(), $return);
1094          $this->assertEquals($e3->id, $return['entry']['id']);
1095      }
1096  
1097  }


Generated: Thu Aug 11 10:00:09 2016 Cross-referenced by PHPXref 0.7.1