[Summary view] [Print] [Text view]

   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  defined('MOODLE_INTERNAL') || die();
  18  
  19  global $CFG;
  20  
  21  require_once($CFG->dirroot . '/webservice/tests/helpers.php');
  22  require_once($CFG->dirroot . '/enrol/externallib.php');
  23  
  24  /**
  25   * Enrol external PHPunit tests
  26   *
  27   * @package    core_enrol
  28   * @category   external
  29   * @copyright  2012 Jerome Mouneyrac
  30   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  31   * @since Moodle 2.4
  32   */
  33  class core_enrol_externallib_testcase extends externallib_advanced_testcase {
  34  
  35      /**
  36       * Test get_enrolled_users
  37       */
  38      public function test_get_enrolled_users() {
  39          global $USER;
  40  
  41          $this->resetAfterTest(true);
  42  
  43          $course = self::getDataGenerator()->create_course();
  44          $user1 = self::getDataGenerator()->create_user();
  45          $user2 = self::getDataGenerator()->create_user();
  46          $user3 = self::getDataGenerator()->create_user();
  47          $this->setUser($user3);
  48  
  49          // Set the required capabilities by the external function.
  50          $context = context_course::instance($course->id);
  51          $roleid = $this->assignUserCapability('moodle/course:viewparticipants', $context->id);
  52          $this->assignUserCapability('moodle/user:viewdetails', $context->id, $roleid);
  53  
  54          // Enrol the users in the course.
  55          $this->getDataGenerator()->enrol_user($user1->id, $course->id, $roleid, 'manual');
  56          $this->getDataGenerator()->enrol_user($user2->id, $course->id, $roleid, 'manual');
  57          $this->getDataGenerator()->enrol_user($user3->id, $course->id, $roleid, 'manual');
  58  
  59          // Call the external function.
  60          $enrolledusers = core_enrol_external::get_enrolled_users($course->id);
  61  
  62          // We need to execute the return values cleaning process to simulate the web service server.
  63          $enrolledusers = external_api::clean_returnvalue(core_enrol_external::get_enrolled_users_returns(), $enrolledusers);
  64  
  65          // Check the result set.
  66          $this->assertEquals(3, count($enrolledusers));
  67          $this->assertArrayHasKey('email', $enrolledusers[0]);
  68  
  69          // Call the function with some parameters set.
  70          $enrolledusers = core_enrol_external::get_enrolled_users($course->id, array(
  71              array('name' => 'limitfrom', 'value' => 2),
  72              array('name' => 'limitnumber', 'value' => 1),
  73              array('name' => 'userfields', 'value' => 'id')
  74          ));
  75  
  76          // We need to execute the return values cleaning process to simulate the web service server.
  77          $enrolledusers = external_api::clean_returnvalue(core_enrol_external::get_enrolled_users_returns(), $enrolledusers);
  78  
  79          // Check the result set, we should only get the 3rd result, which is $user3.
  80          $this->assertCount(1, $enrolledusers);
  81          $this->assertEquals($user3->id, $enrolledusers[0]['id']);
  82          $this->assertArrayHasKey('id', $enrolledusers[0]);
  83          $this->assertArrayNotHasKey('email', $enrolledusers[0]);
  84  
  85          // Call without required capability.
  86          $this->unassignUserCapability('moodle/course:viewparticipants', $context->id, $roleid);
  87          $this->setExpectedException('moodle_exception');
  88          $categories = core_enrol_external::get_enrolled_users($course->id);
  89      }
  90  
  91      /**
  92       * Test get_users_courses
  93       */
  94      public function test_get_users_courses() {
  95          global $USER;
  96  
  97          $this->resetAfterTest(true);
  98  
  99          $course1 = self::getDataGenerator()->create_course();
 100          $course2 = self::getDataGenerator()->create_course();
 101          $courses = array($course1, $course2);
 102  
 103          // Enrol $USER in the courses.
 104          // We use the manual plugin.
 105          $roleid = null;
 106          foreach ($courses as $course) {
 107              $context = context_course::instance($course->id);
 108              $roleid = $this->assignUserCapability('moodle/course:viewparticipants',
 109                      $context->id, $roleid);
 110  
 111              $this->getDataGenerator()->enrol_user($USER->id, $course->id, $roleid, 'manual');
 112          }
 113  
 114          // Call the external function.
 115          $enrolledincourses = core_enrol_external::get_users_courses($USER->id);
 116  
 117          // We need to execute the return values cleaning process to simulate the web service server.
 118          $enrolledincourses = external_api::clean_returnvalue(core_enrol_external::get_users_courses_returns(), $enrolledincourses);
 119  
 120          // Check we retrieve the good total number of enrolled users.
 121          $this->assertEquals(2, count($enrolledincourses));
 122      }
 123  
 124      /**
 125       * Test get_enrolled_users_with_capability
 126       */
 127      public function test_get_enrolled_users_with_capability () {
 128          global $DB, $USER;
 129  
 130          $this->resetAfterTest(true);
 131  
 132          $user1 = $this->getDataGenerator()->create_user();
 133  
 134          $coursedata['idnumber'] = 'idnumbercourse1';
 135          $coursedata['fullname'] = 'Lightwork Course 1';
 136          $coursedata['summary'] = 'Lightwork Course 1 description';
 137          $coursedata['summaryformat'] = FORMAT_MOODLE;
 138          $course1  = self::getDataGenerator()->create_course($coursedata);
 139  
 140          // Create a manual enrolment record.
 141          $manual_enrol_data['enrol'] = 'manual';
 142          $manual_enrol_data['status'] = 0;
 143          $manual_enrol_data['courseid'] = $course1->id;
 144          $enrolid = $DB->insert_record('enrol', $manual_enrol_data);
 145  
 146          // Create the users and give them capabilities in the course context.
 147          $context = context_course::instance($course1->id);
 148          $roleid = $this->assignUserCapability('moodle/course:viewparticipants', $context->id, 3);
 149  
 150          // Create 2 students.
 151          $student1 = self::getDataGenerator()->create_user();
 152          $student2 = self::getDataGenerator()->create_user();
 153  
 154          // Give the capability to student2.
 155          assign_capability('moodle/course:viewparticipants', CAP_ALLOW, 3, $context->id);
 156          role_assign(3, $student2->id, $context->id);
 157          accesslib_clear_all_caches_for_unit_testing();
 158  
 159          // Enrol both the user and the students in the course.
 160          $user_enrolment_data['status'] = 0;
 161          $user_enrolment_data['enrolid'] = $enrolid;
 162          $user_enrolment_data['userid'] = $USER->id;
 163          $DB->insert_record('user_enrolments', $user_enrolment_data);
 164  
 165          $user_enrolment_data['status'] = 0;
 166          $user_enrolment_data['enrolid'] = $enrolid;
 167          $user_enrolment_data['userid'] = $student1->id;
 168          $DB->insert_record('user_enrolments', $user_enrolment_data);
 169  
 170          $user_enrolment_data['status'] = 0;
 171          $user_enrolment_data['enrolid'] = $enrolid;
 172          $user_enrolment_data['userid'] = $student2->id;
 173          $DB->insert_record('user_enrolments', $user_enrolment_data);
 174  
 175          $params = array("coursecapabilities" => array('courseid' => $course1->id,
 176              'capabilities' => array('moodle/course:viewparticipants')));
 177          $options = array();
 178          $result = core_enrol_external::get_enrolled_users_with_capability($params, $options);
 179  
 180          // We need to execute the return values cleaning process to simulate the web service server.
 181          $result = external_api::clean_returnvalue(core_enrol_external::get_enrolled_users_with_capability_returns(), $result);
 182  
 183          // Check an array containing the expected user for the course capability is returned.
 184          $expecteduserlist = $result[0];
 185          $this->assertEquals($course1->id, $expecteduserlist['courseid']);
 186          $this->assertEquals('moodle/course:viewparticipants', $expecteduserlist['capability']);
 187          $this->assertEquals(2, count($expecteduserlist['users']));
 188  
 189          // Now doing the query again with options.
 190          $params = array(
 191              "coursecapabilities" => array(
 192                  'courseid' => $course1->id,
 193                  'capabilities' => array('moodle/course:viewparticipants')
 194              )
 195          );
 196          $options = array(
 197              array('name' => 'limitfrom', 'value' => 1),
 198              array('name' => 'limitnumber', 'value' => 1),
 199              array('name' => 'userfields', 'value' => 'id')
 200          );
 201  
 202          $result = core_enrol_external::get_enrolled_users_with_capability($params, $options);
 203  
 204          // We need to execute the return values cleaning process to simulate the web service server.
 205          $result = external_api::clean_returnvalue(core_enrol_external::get_enrolled_users_with_capability_returns(), $result);
 206  
 207          // Check an array containing the expected user for the course capability is returned.
 208          $expecteduserlist = $result[0]['users'];
 209          $expecteduser = reset($expecteduserlist);
 210          $this->assertEquals(1, count($expecteduserlist));
 211          $this->assertEquals($student2->id, $expecteduser['id']);
 212      }
 213  
 214      /**
 215       * Test get_course_enrolment_methods
 216       */
 217      public function test_get_course_enrolment_methods() {
 218          global $DB;
 219  
 220          $this->resetAfterTest(true);
 221  
 222          // Get enrolment plugins.
 223          $selfplugin = enrol_get_plugin('self');
 224          $this->assertNotEmpty($selfplugin);
 225          $manualplugin = enrol_get_plugin('manual');
 226          $this->assertNotEmpty($manualplugin);
 227  
 228          $studentrole = $DB->get_record('role', array('shortname'=>'student'));
 229          $this->assertNotEmpty($studentrole);
 230  
 231          $course1 = self::getDataGenerator()->create_course();
 232          $course2 = self::getDataGenerator()->create_course();
 233  
 234          // Add enrolment methods for course.
 235          $instanceid1 = $selfplugin->add_instance($course1, array('status' => ENROL_INSTANCE_ENABLED,
 236                                                                  'name' => 'Test instance 1',
 237                                                                  'customint6' => 1,
 238                                                                  'roleid' => $studentrole->id));
 239          $instanceid2 = $selfplugin->add_instance($course1, array('status' => ENROL_INSTANCE_DISABLED,
 240                                                                  'name' => 'Test instance 2',
 241                                                                  'roleid' => $studentrole->id));
 242  
 243          $instanceid3 = $manualplugin->add_instance($course1, array('status' => ENROL_INSTANCE_ENABLED,
 244                                                                  'name' => 'Test instance 3'));
 245  
 246          $enrolmentmethods = $DB->get_records('enrol', array('courseid' => $course1->id, 'status' => ENROL_INSTANCE_ENABLED));
 247          $this->assertCount(2, $enrolmentmethods);
 248  
 249          // Check if information is returned.
 250          $enrolmentmethods = core_enrol_external::get_course_enrolment_methods($course1->id);
 251          // Enrolment information is currently returned by self enrolment plugin, so count == 1.
 252          // This should be changed as we implement get_enrol_info() for other enrolment plugins.
 253          $this->assertCount(1, $enrolmentmethods);
 254  
 255          $enrolmentmethod = $enrolmentmethods[0];
 256          $this->assertEquals($course1->id, $enrolmentmethod['courseid']);
 257          $this->assertEquals('self', $enrolmentmethod['type']);
 258          $this->assertTrue($enrolmentmethod['status']);
 259          $this->assertFalse(isset($enrolmentmethod['wsfunction']));
 260  
 261          $instanceid4 = $selfplugin->add_instance($course2, array('status' => ENROL_INSTANCE_ENABLED,
 262                                                                  'name' => 'Test instance 4',
 263                                                                  'roleid' => $studentrole->id,
 264                                                                  'customint6' => 1,
 265                                                                  'password' => 'test'));
 266          $enrolmentmethods = core_enrol_external::get_course_enrolment_methods($course2->id);
 267          $this->assertCount(1, $enrolmentmethods);
 268  
 269          $enrolmentmethod = $enrolmentmethods[0];
 270          $this->assertEquals($course2->id, $enrolmentmethod['courseid']);
 271          $this->assertEquals('self', $enrolmentmethod['type']);
 272          $this->assertTrue($enrolmentmethod['status']);
 273          $this->assertEquals('enrol_self_get_instance_info', $enrolmentmethod['wsfunction']);
 274      }
 275  }