[ Index ]

PHP Cross Reference of Unnamed Project

title

Body

[close]

/admin/tool/lp/tests/ -> externallib_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   * External learning plans webservice API tests.
  18   *
  19   * @package tool_lp
  20   * @copyright 2015 Damyon Wiese
  21   * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  22   */
  23  
  24  defined('MOODLE_INTERNAL') || die();
  25  
  26  global $CFG;
  27  
  28  require_once($CFG->dirroot . '/webservice/tests/helpers.php');
  29  
  30  use core_competency\api;
  31  use tool_lp\external;
  32  use core_competency\invalid_persistent_exception;
  33  use core_competency\plan;
  34  use core_competency\related_competency;
  35  use core_competency\user_competency;
  36  use core_competency\user_competency_plan;
  37  use core_competency\plan_competency;
  38  use core_competency\template;
  39  use core_competency\template_competency;
  40  use core_competency\course_competency_settings;
  41  
  42  /**
  43   * External learning plans webservice API tests.
  44   *
  45   * @package tool_lp
  46   * @copyright 2015 Damyon Wiese
  47   * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  48   */
  49  class tool_lp_external_testcase extends externallib_advanced_testcase {
  50  
  51      /** @var stdClass $creator User with enough permissions to create insystem context. */
  52      protected $creator = null;
  53  
  54      /** @var stdClass $catcreator User with enough permissions to create incategory context. */
  55      protected $catcreator = null;
  56  
  57      /** @var stdClass $category Category */
  58      protected $category = null;
  59  
  60      /** @var stdClass $category Category */
  61      protected $othercategory = null;
  62  
  63      /** @var stdClass $user User with enough permissions to view insystem context */
  64      protected $user = null;
  65  
  66      /** @var stdClass $catuser User with enough permissions to view incategory context */
  67      protected $catuser = null;
  68  
  69      /** @var int Creator role id */
  70      protected $creatorrole = null;
  71  
  72      /** @var int User role id */
  73      protected $userrole = null;
  74  
  75      /**
  76       * Setup function- we will create a course and add an assign instance to it.
  77       */
  78      protected function setUp() {
  79          global $DB;
  80  
  81          $this->resetAfterTest(true);
  82  
  83          // Create some users.
  84          $creator = $this->getDataGenerator()->create_user();
  85          $user = $this->getDataGenerator()->create_user();
  86          $catuser = $this->getDataGenerator()->create_user();
  87          $catcreator = $this->getDataGenerator()->create_user();
  88          $category = $this->getDataGenerator()->create_category();
  89          $othercategory = $this->getDataGenerator()->create_category();
  90          $syscontext = context_system::instance();
  91          $catcontext = context_coursecat::instance($category->id);
  92  
  93          // Fetching default authenticated user role.
  94          $userroles = get_archetype_roles('user');
  95          $this->assertCount(1, $userroles);
  96          $authrole = array_pop($userroles);
  97  
  98          // Reset all default authenticated users permissions.
  99          unassign_capability('moodle/competency:competencygrade', $authrole->id);
 100          unassign_capability('moodle/competency:competencymanage', $authrole->id);
 101          unassign_capability('moodle/competency:competencyview', $authrole->id);
 102          unassign_capability('moodle/competency:planmanage', $authrole->id);
 103          unassign_capability('moodle/competency:planmanagedraft', $authrole->id);
 104          unassign_capability('moodle/competency:planmanageown', $authrole->id);
 105          unassign_capability('moodle/competency:planview', $authrole->id);
 106          unassign_capability('moodle/competency:planviewdraft', $authrole->id);
 107          unassign_capability('moodle/competency:planviewown', $authrole->id);
 108          unassign_capability('moodle/competency:planviewowndraft', $authrole->id);
 109          unassign_capability('moodle/competency:templatemanage', $authrole->id);
 110          unassign_capability('moodle/competency:templateview', $authrole->id);
 111          unassign_capability('moodle/cohort:manage', $authrole->id);
 112          unassign_capability('moodle/competency:coursecompetencyconfigure', $authrole->id);
 113  
 114          // Creating specific roles.
 115          $this->creatorrole = create_role('Creator role', 'lpcreatorrole', 'learning plan creator role description');
 116          $this->userrole = create_role('User role', 'lpuserrole', 'learning plan user role description');
 117  
 118          assign_capability('moodle/competency:competencymanage', CAP_ALLOW, $this->creatorrole, $syscontext->id);
 119          assign_capability('moodle/competency:competencycompetencyconfigure', CAP_ALLOW, $this->creatorrole, $syscontext->id);
 120          assign_capability('moodle/competency:planmanage', CAP_ALLOW, $this->creatorrole, $syscontext->id);
 121          assign_capability('moodle/competency:planmanagedraft', CAP_ALLOW, $this->creatorrole, $syscontext->id);
 122          assign_capability('moodle/competency:planmanageown', CAP_ALLOW, $this->creatorrole, $syscontext->id);
 123          assign_capability('moodle/competency:planview', CAP_ALLOW, $this->creatorrole, $syscontext->id);
 124          assign_capability('moodle/competency:planviewdraft', CAP_ALLOW, $this->creatorrole, $syscontext->id);
 125          assign_capability('moodle/competency:templatemanage', CAP_ALLOW, $this->creatorrole, $syscontext->id);
 126          assign_capability('moodle/competency:competencygrade', CAP_ALLOW, $this->creatorrole, $syscontext->id);
 127          assign_capability('moodle/cohort:manage', CAP_ALLOW, $this->creatorrole, $syscontext->id);
 128  
 129          assign_capability('moodle/competency:competencyview', CAP_ALLOW, $this->userrole, $syscontext->id);
 130          assign_capability('moodle/competency:templateview', CAP_ALLOW, $this->userrole, $syscontext->id);
 131          assign_capability('moodle/competency:planviewown', CAP_ALLOW, $this->userrole, $syscontext->id);
 132          assign_capability('moodle/competency:planviewowndraft', CAP_ALLOW, $this->userrole, $syscontext->id);
 133  
 134          role_assign($this->creatorrole, $creator->id, $syscontext->id);
 135          role_assign($this->creatorrole, $catcreator->id, $catcontext->id);
 136          role_assign($this->userrole, $user->id, $syscontext->id);
 137          role_assign($this->userrole, $catuser->id, $catcontext->id);
 138  
 139          $this->creator = $creator;
 140          $this->catcreator = $catcreator;
 141          $this->user = $user;
 142          $this->catuser = $catuser;
 143          $this->category = $category;
 144          $this->othercategory = $othercategory;
 145  
 146          accesslib_clear_all_caches_for_unit_testing();
 147      }
 148  
 149      public function test_search_users_by_capability() {
 150          global $CFG;
 151          $this->resetAfterTest(true);
 152  
 153          $dg = $this->getDataGenerator();
 154          $ux = $dg->create_user();
 155          $u1 = $dg->create_user(array('idnumber' => 'Cats', 'firstname' => 'Bob', 'lastname' => 'Dyyylan',
 156              'email' => 'bobbyyy@dyyylan.com', 'phone1' => '123456', 'phone2' => '78910', 'department' => 'Marketing',
 157              'institution' => 'HQ'));
 158  
 159          // First we search with no capability assigned.
 160          $this->setUser($ux);
 161          $result = external::search_users('yyylan', 'moodle/competency:planmanage');
 162          $result = external_api::clean_returnvalue(external::search_users_returns(), $result);
 163          $this->assertCount(0, $result['users']);
 164          $this->assertEquals(0, $result['count']);
 165  
 166          // Now we assign a different capability.
 167          $usercontext = context_user::instance($u1->id);
 168          $systemcontext = context_system::instance();
 169          $customrole = $this->assignUserCapability('moodle/competency:planview', $usercontext->id);
 170  
 171          $result = external::search_users('yyylan', 'moodle/competency:planmanage');
 172          $result = external_api::clean_returnvalue(external::search_users_returns(), $result);
 173          $this->assertCount(0, $result['users']);
 174          $this->assertEquals(0, $result['count']);
 175  
 176          // Now we assign a matching capability in the same role.
 177          $usercontext = context_user::instance($u1->id);
 178          $this->assignUserCapability('moodle/competency:planmanage', $usercontext->id, $customrole);
 179  
 180          $result = external::search_users('yyylan', 'moodle/competency:planmanage');
 181          $result = external_api::clean_returnvalue(external::search_users_returns(), $result);
 182          $this->assertCount(1, $result['users']);
 183          $this->assertEquals(1, $result['count']);
 184  
 185          // Now assign another role with the same capability (test duplicates).
 186          role_assign($this->creatorrole, $ux->id, $usercontext->id);
 187          $result = external::search_users('yyylan', 'moodle/competency:planmanage');
 188          $result = external_api::clean_returnvalue(external::search_users_returns(), $result);
 189          $this->assertCount(1, $result['users']);
 190          $this->assertEquals(1, $result['count']);
 191  
 192          // Now lets try a different user with only the role at system level.
 193          $ux2 = $dg->create_user();
 194          role_assign($this->creatorrole, $ux2->id, $systemcontext->id);
 195          $this->setUser($ux2);
 196          $result = external::search_users('yyylan', 'moodle/competency:planmanage');
 197          $result = external_api::clean_returnvalue(external::search_users_returns(), $result);
 198          $this->assertCount(1, $result['users']);
 199          $this->assertEquals(1, $result['count']);
 200  
 201          // Now lets try a different user with only the role at user level.
 202          $ux3 = $dg->create_user();
 203          role_assign($this->creatorrole, $ux3->id, $usercontext->id);
 204          $this->setUser($ux3);
 205          $result = external::search_users('yyylan', 'moodle/competency:planmanage');
 206          $result = external_api::clean_returnvalue(external::search_users_returns(), $result);
 207          $this->assertCount(1, $result['users']);
 208          $this->assertEquals(1, $result['count']);
 209  
 210          // Switch back.
 211          $this->setUser($ux);
 212  
 213          // Now add a prevent override (will change nothing because we still have an ALLOW).
 214          assign_capability('moodle/competency:planmanage', CAP_PREVENT, $customrole, $usercontext->id);
 215          $result = external::search_users('yyylan', 'moodle/competency:planmanage');
 216          $result = external_api::clean_returnvalue(external::search_users_returns(), $result);
 217          $this->assertCount(1, $result['users']);
 218          $this->assertEquals(1, $result['count']);
 219  
 220          // Now change to a prohibit override (should prevent access).
 221          assign_capability('moodle/competency:planmanage', CAP_PROHIBIT, $customrole, $usercontext->id);
 222          $result = external::search_users('yyylan', 'moodle/competency:planmanage');
 223          $result = external_api::clean_returnvalue(external::search_users_returns(), $result);
 224          $this->assertCount(1, $result['users']);
 225          $this->assertEquals(1, $result['count']);
 226  
 227      }
 228  
 229      /**
 230       * Ensures that overrides, as well as system permissions, are respected.
 231       */
 232      public function test_search_users_by_capability_the_comeback() {
 233          $this->resetAfterTest();
 234          $dg = $this->getDataGenerator();
 235  
 236          $master = $dg->create_user();
 237          $manager = $dg->create_user();
 238          $slave1 = $dg->create_user(array('lastname' => 'MOODLER'));
 239          $slave2 = $dg->create_user(array('lastname' => 'MOODLER'));
 240          $slave3 = $dg->create_user(array('lastname' => 'MOODLER'));
 241  
 242          $syscontext = context_system::instance();
 243          $slave1context = context_user::instance($slave1->id);
 244          $slave2context = context_user::instance($slave2->id);
 245          $slave3context = context_user::instance($slave3->id);
 246  
 247          // Creating a role giving the site config.
 248          $roleid = $dg->create_role();
 249          assign_capability('moodle/site:config', CAP_ALLOW, $roleid, $syscontext->id, true);
 250  
 251          // Create a role override for slave 2.
 252          assign_capability('moodle/site:config', CAP_PROHIBIT, $roleid, $slave2context->id, true);
 253  
 254          // Assigning the role.
 255          // Master -> System context.
 256          // Manager -> User context.
 257          role_assign($roleid, $master->id, $syscontext);
 258          role_assign($roleid, $manager->id, $slave1context);
 259  
 260          // Flush accesslib.
 261          accesslib_clear_all_caches_for_unit_testing();
 262  
 263          // Confirm.
 264          // Master has system permissions.
 265          $this->setUser($master);
 266          $this->assertTrue(has_capability('moodle/site:config', $syscontext));
 267          $this->assertTrue(has_capability('moodle/site:config', $slave1context));
 268          $this->assertFalse(has_capability('moodle/site:config', $slave2context));
 269          $this->assertTrue(has_capability('moodle/site:config', $slave3context));
 270  
 271          // Manager only has permissions in slave 1.
 272          $this->setUser($manager);
 273          $this->assertFalse(has_capability('moodle/site:config', $syscontext));
 274          $this->assertTrue(has_capability('moodle/site:config', $slave1context));
 275          $this->assertFalse(has_capability('moodle/site:config', $slave2context));
 276          $this->assertFalse(has_capability('moodle/site:config', $slave3context));
 277  
 278          // Now do the test.
 279          $this->setUser($master);
 280          $result = external::search_users('MOODLER', 'moodle/site:config');
 281          $this->assertCount(2, $result['users']);
 282          $this->assertEquals(2, $result['count']);
 283          $this->assertArrayHasKey($slave1->id, $result['users']);
 284          $this->assertArrayHasKey($slave3->id, $result['users']);
 285  
 286          $this->setUser($manager);
 287          $result = external::search_users('MOODLER', 'moodle/site:config');
 288          $this->assertCount(1, $result['users']);
 289          $this->assertEquals(1, $result['count']);
 290          $this->assertArrayHasKey($slave1->id, $result['users']);
 291      }
 292  
 293      public function test_search_users() {
 294          global $CFG;
 295          $this->resetAfterTest(true);
 296  
 297          $dg = $this->getDataGenerator();
 298          $ux = $dg->create_user();
 299          $u1 = $dg->create_user(array('idnumber' => 'Cats', 'firstname' => 'Bob', 'lastname' => 'Dyyylan',
 300              'email' => 'bobbyyy@dyyylan.com', 'phone1' => '123456', 'phone2' => '78910', 'department' => 'Marketing',
 301              'institution' => 'HQ'));
 302          $u2 = $dg->create_user(array('idnumber' => 'Dogs', 'firstname' => 'Alice', 'lastname' => 'Dyyylan',
 303              'email' => 'alyyyson@dyyylan.com', 'phone1' => '33333', 'phone2' => '77777', 'department' => 'Development',
 304              'institution' => 'O2'));
 305          $u3 = $dg->create_user(array('idnumber' => 'Fish', 'firstname' => 'Thomas', 'lastname' => 'Xow',
 306              'email' => 'fishyyy@moodle.com', 'phone1' => '77777', 'phone2' => '33333', 'department' => 'Research',
 307              'institution' => 'Bob'));
 308  
 309          // We need to give the user the capability we are searching for on each of the test users.
 310          $this->setAdminUser();
 311          $usercontext = context_user::instance($u1->id);
 312          $dummyrole = $this->assignUserCapability('moodle/competency:planmanage', $usercontext->id);
 313          $usercontext = context_user::instance($u2->id);
 314          $this->assignUserCapability('moodle/competency:planmanage', $usercontext->id, $dummyrole);
 315          $usercontext = context_user::instance($u3->id);
 316          $this->assignUserCapability('moodle/competency:planmanage', $usercontext->id, $dummyrole);
 317  
 318          $this->setUser($ux);
 319          $usercontext = context_user::instance($u1->id);
 320          $this->assignUserCapability('moodle/competency:planmanage', $usercontext->id, $dummyrole);
 321          $usercontext = context_user::instance($u2->id);
 322          $this->assignUserCapability('moodle/competency:planmanage', $usercontext->id, $dummyrole);
 323          $usercontext = context_user::instance($u3->id);
 324          $this->assignUserCapability('moodle/competency:planmanage', $usercontext->id, $dummyrole);
 325  
 326          $this->setAdminUser();
 327  
 328          // No identity fields.
 329          $CFG->showuseridentity = '';
 330          $result = external::search_users('cats', 'moodle/competency:planmanage');
 331          $result = external_api::clean_returnvalue(external::search_users_returns(), $result);
 332          $this->assertCount(0, $result['users']);
 333          $this->assertEquals(0, $result['count']);
 334  
 335          // Filter by name.
 336          $CFG->showuseridentity = '';
 337          $result = external::search_users('dyyylan', 'moodle/competency:planmanage');
 338          $result = external_api::clean_returnvalue(external::search_users_returns(), $result);
 339          $this->assertCount(2, $result['users']);
 340          $this->assertEquals(2, $result['count']);
 341          $this->assertEquals($u2->id, $result['users'][0]['id']);
 342          $this->assertEquals($u1->id, $result['users'][1]['id']);
 343  
 344          // Filter by institution and name.
 345          $CFG->showuseridentity = 'institution';
 346          $result = external::search_users('bob', 'moodle/competency:planmanage');
 347          $result = external_api::clean_returnvalue(external::search_users_returns(), $result);
 348          $this->assertCount(2, $result['users']);
 349          $this->assertEquals(2, $result['count']);
 350          $this->assertEquals($u1->id, $result['users'][0]['id']);
 351          $this->assertEquals($u3->id, $result['users'][1]['id']);
 352  
 353          // Filter by id number.
 354          $CFG->showuseridentity = 'idnumber';
 355          $result = external::search_users('cats', 'moodle/competency:planmanage');
 356          $result = external_api::clean_returnvalue(external::search_users_returns(), $result);
 357          $this->assertCount(1, $result['users']);
 358          $this->assertEquals(1, $result['count']);
 359          $this->assertEquals($u1->id, $result['users'][0]['id']);
 360          $this->assertEquals($u1->idnumber, $result['users'][0]['idnumber']);
 361          $this->assertEmpty($result['users'][0]['email']);
 362          $this->assertEmpty($result['users'][0]['phone1']);
 363          $this->assertEmpty($result['users'][0]['phone2']);
 364          $this->assertEmpty($result['users'][0]['department']);
 365          $this->assertEmpty($result['users'][0]['institution']);
 366  
 367          // Filter by email.
 368          $CFG->showuseridentity = 'email';
 369          $result = external::search_users('yyy', 'moodle/competency:planmanage');
 370          $result = external_api::clean_returnvalue(external::search_users_returns(), $result);
 371          $this->assertCount(3, $result['users']);
 372          $this->assertEquals(3, $result['count']);
 373          $this->assertEquals($u2->id, $result['users'][0]['id']);
 374          $this->assertEquals($u2->email, $result['users'][0]['email']);
 375          $this->assertEquals($u1->id, $result['users'][1]['id']);
 376          $this->assertEquals($u1->email, $result['users'][1]['email']);
 377          $this->assertEquals($u3->id, $result['users'][2]['id']);
 378          $this->assertEquals($u3->email, $result['users'][2]['email']);
 379  
 380          // Filter by any.
 381          $CFG->showuseridentity = 'idnumber,email,phone1,phone2,department,institution';
 382          $result = external::search_users('yyy', 'moodle/competency:planmanage');
 383          $result = external_api::clean_returnvalue(external::search_users_returns(), $result);
 384          $this->assertCount(3, $result['users']);
 385          $this->assertEquals(3, $result['count']);
 386          $this->assertArrayHasKey('idnumber', $result['users'][0]);
 387          $this->assertArrayHasKey('email', $result['users'][0]);
 388          $this->assertArrayHasKey('phone1', $result['users'][0]);
 389          $this->assertArrayHasKey('phone2', $result['users'][0]);
 390          $this->assertArrayHasKey('department', $result['users'][0]);
 391          $this->assertArrayHasKey('institution', $result['users'][0]);
 392  
 393          // Switch to a user that cannot view identity fields.
 394          $this->setUser($ux);
 395          $CFG->showuseridentity = 'idnumber,email,phone1,phone2,department,institution';
 396  
 397          // Only names are included.
 398          $result = external::search_users('fish');
 399          $result = external_api::clean_returnvalue(external::search_users_returns(), $result);
 400          $this->assertCount(0, $result['users']);
 401          $this->assertEquals(0, $result['count']);
 402  
 403          $result = external::search_users('bob', 'moodle/competency:planmanage');
 404          $result = external_api::clean_returnvalue(external::search_users_returns(), $result);
 405          $this->assertCount(1, $result['users']);
 406          $this->assertEquals(1, $result['count']);
 407          $this->assertEquals($u1->id, $result['users'][0]['id']);
 408          $this->assertEmpty($result['users'][0]['idnumber']);
 409          $this->assertEmpty($result['users'][0]['email']);
 410          $this->assertEmpty($result['users'][0]['phone1']);
 411          $this->assertEmpty($result['users'][0]['phone2']);
 412          $this->assertEmpty($result['users'][0]['department']);
 413          $this->assertEmpty($result['users'][0]['institution']);
 414      }
 415  
 416      public function test_data_for_user_competency_summary_in_plan() {
 417          global $CFG;
 418  
 419          $this->setUser($this->creator);
 420  
 421          $dg = $this->getDataGenerator();
 422          $lpg = $dg->get_plugin_generator('core_competency');
 423  
 424          $f1 = $lpg->create_framework();
 425  
 426          $c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
 427  
 428          $tpl = $lpg->create_template();
 429          $lpg->create_template_competency(array('templateid' => $tpl->get_id(), 'competencyid' => $c1->get_id()));
 430  
 431          $plan = $lpg->create_plan(array('userid' => $this->user->id, 'templateid' => $tpl->get_id(), 'name' => 'Evil'));
 432  
 433          $uc = $lpg->create_user_competency(array('userid' => $this->user->id, 'competencyid' => $c1->get_id()));
 434  
 435          $evidence = \core_competency\external::grade_competency_in_plan($plan->get_id(), $c1->get_id(), 1, true);
 436          $evidence = \core_competency\external::grade_competency_in_plan($plan->get_id(), $c1->get_id(), 2, true);
 437  
 438          $summary = external::data_for_user_competency_summary_in_plan($c1->get_id(), $plan->get_id());
 439          $this->assertTrue($summary->usercompetencysummary->cangrade);
 440          $this->assertEquals('Evil', $summary->plan->name);
 441          $this->assertEquals('B', $summary->usercompetencysummary->usercompetency->gradename);
 442          $this->assertEquals('B', $summary->usercompetencysummary->evidence[0]->gradename);
 443          $this->assertEquals('A', $summary->usercompetencysummary->evidence[1]->gradename);
 444      }
 445  
 446      /**
 447       * Search cohorts.
 448       */
 449      public function test_search_cohorts() {
 450          $this->resetAfterTest(true);
 451  
 452          $syscontext = array('contextid' => context_system::instance()->id);
 453          $catcontext = array('contextid' => context_coursecat::instance($this->category->id)->id);
 454          $othercatcontext = array('contextid' => context_coursecat::instance($this->othercategory->id)->id);
 455  
 456          $cohort1 = $this->getDataGenerator()->create_cohort(array_merge($syscontext, array('name' => 'Cohortsearch 1')));
 457          $cohort2 = $this->getDataGenerator()->create_cohort(array_merge($catcontext, array('name' => 'Cohortsearch 2')));
 458          $cohort3 = $this->getDataGenerator()->create_cohort(array_merge($othercatcontext, array('name' => 'Cohortsearch 3')));
 459  
 460          // Check for parameter $includes = 'parents'.
 461  
 462          // A user without permission in the system.
 463          $this->setUser($this->user);
 464          try {
 465              $result = external::search_cohorts("Cohortsearch", $syscontext, 'parents');
 466              $this->fail('Invalid permissions in system');
 467          } catch (required_capability_exception $e) {
 468              // All good.
 469          }
 470  
 471          // A user without permission in a category.
 472          $this->setUser($this->catuser);
 473          try {
 474              $result = external::search_cohorts("Cohortsearch", $catcontext, 'parents');
 475              $this->fail('Invalid permissions in category');
 476          } catch (required_capability_exception $e) {
 477              // All good.
 478          }
 479  
 480          // A user with permissions in the system.
 481          $this->setUser($this->creator);
 482          $result = external::search_cohorts("Cohortsearch", $syscontext, 'parents');
 483          $this->assertEquals(1, count($result['cohorts']));
 484          $this->assertEquals('Cohortsearch 1', $result['cohorts'][$cohort1->id]->name);
 485  
 486          // A user with permissions in the category.
 487          $this->setUser($this->catcreator);
 488          $result = external::search_cohorts("Cohortsearch", $catcontext, 'parents');
 489          $this->assertEquals(2, count($result['cohorts']));
 490          $cohorts = array();
 491          foreach ($result['cohorts'] as $cohort) {
 492              $cohorts[] = $cohort->name;
 493          }
 494          $this->assertTrue(in_array('Cohortsearch 1', $cohorts));
 495          $this->assertTrue(in_array('Cohortsearch 2', $cohorts));
 496  
 497          // Check for parameter $includes = 'self'.
 498          $this->setUser($this->creator);
 499          $result = external::search_cohorts("Cohortsearch", $othercatcontext, 'self');
 500          $this->assertEquals(1, count($result['cohorts']));
 501          $this->assertEquals('Cohortsearch 3', $result['cohorts'][$cohort3->id]->name);
 502  
 503          // Check for parameter $includes = 'all'.
 504          $this->setUser($this->creator);
 505          $result = external::search_cohorts("Cohortsearch", $syscontext, 'all');
 506          $this->assertEquals(3, count($result['cohorts']));
 507  
 508          // Detect invalid parameter $includes.
 509          $this->setUser($this->creator);
 510          try {
 511              $result = external::search_cohorts("Cohortsearch", $syscontext, 'invalid');
 512              $this->fail('Invalid parameter includes');
 513          } catch (coding_exception $e) {
 514              // All good.
 515          }
 516      }
 517  
 518  }


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