[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  /**
  18   * Test the helper functionality.
  19   *
  20   * @package enrol_lti
  21   * @copyright 2016 Mark Nelson <markn@moodle.com>
  22   * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23   */
  24  
  25  defined('MOODLE_INTERNAL') || die();
  26  
  27  /**
  28   * Test the helper functionality.
  29   *
  30   * @package enrol_lti
  31   * @copyright 2016 Mark Nelson <markn@moodle.com>
  32   * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  33   */
  34  class enrol_lti_helper_testcase extends advanced_testcase {
  35  
  36      /**
  37       * @var stdClass $user1 A user.
  38       */
  39      public $user1;
  40  
  41      /**
  42       * @var stdClass $user2 A user.
  43       */
  44      public $user2;
  45  
  46      /**
  47       * Test set up.
  48       *
  49       * This is executed before running any test in this file.
  50       */
  51      public function setUp() {
  52          $this->resetAfterTest();
  53  
  54          // Set this user as the admin.
  55          $this->setAdminUser();
  56  
  57          // Get some of the information we need.
  58          $this->user1 = self::getDataGenerator()->create_user();
  59          $this->user2 = self::getDataGenerator()->create_user();
  60      }
  61  
  62      /**
  63       * Test the update user profile image function.
  64       */
  65      public function test_update_user_profile_image() {
  66          global $DB, $CFG;
  67  
  68          // Set the profile image.
  69          \enrol_lti\helper::update_user_profile_image($this->user1->id, $this->getExternalTestFileUrl('/test.jpg'));
  70  
  71          // Get the new user record.
  72          $this->user1 = $DB->get_record('user', array('id' => $this->user1->id));
  73  
  74          // Set the page details.
  75          $page = new moodle_page();
  76          $page->set_url('/user/profile.php');
  77          $page->set_context(context_system::instance());
  78          $renderer = $page->get_renderer('core');
  79          $usercontext = context_user::instance($this->user1->id);
  80  
  81          // Get the user's profile picture and make sure it is correct.
  82          $userpicture = new user_picture($this->user1);
  83          $this->assertSame($CFG->wwwroot . '/pluginfile.php/' . $usercontext->id . '/user/icon/clean/f2?rev=' .$this->user1->picture,
  84              $userpicture->get_url($page, $renderer)->out(false));
  85      }
  86  
  87      /**
  88       * Test that we can not enrol past the maximum number of users allowed.
  89       */
  90      public function test_enrol_user_max_enrolled() {
  91          global $DB;
  92  
  93          // Set up the LTI enrolment tool.
  94          $data = new stdClass();
  95          $data->maxenrolled = 1;
  96          $tool = $this->create_tool($data);
  97  
  98          // Now get all the information we need.
  99          $tool = \enrol_lti\helper::get_lti_tool($tool->id);
 100  
 101          // Enrol a user.
 102          $result = \enrol_lti\helper::enrol_user($tool, $this->user1->id);
 103  
 104          // Check that the user was enrolled.
 105          $this->assertEquals(true, $result);
 106          $this->assertEquals(1, $DB->count_records('user_enrolments', array('enrolid' => $tool->enrolid)));
 107  
 108          // Try and enrol another user - should not happen.
 109          $result = \enrol_lti\helper::enrol_user($tool, $this->user2->id);
 110  
 111          // Check that this user was not enrolled and we are told why.
 112          $this->assertEquals(\enrol_lti\helper::ENROLMENT_MAX_ENROLLED, $result);
 113          $this->assertEquals(1, $DB->count_records('user_enrolments', array('enrolid' => $tool->enrolid)));
 114      }
 115  
 116      /**
 117       * Test that we can not enrol when the enrolment has not started.
 118       */
 119      public function test_enrol_user_enrolment_not_started() {
 120          global $DB;
 121  
 122          // Set up the LTI enrolment tool.
 123          $data = new stdClass();
 124          $data->enrolstartdate = time() + DAYSECS; // Make sure it is in the future.
 125          $tool = $this->create_tool($data);
 126  
 127          // Now get all the information we need.
 128          $tool = \enrol_lti\helper::get_lti_tool($tool->id);
 129  
 130          // Try and enrol a user - should not happen.
 131          $result = \enrol_lti\helper::enrol_user($tool, $this->user1->id);
 132  
 133          // Check that this user was not enrolled and we are told why.
 134          $this->assertEquals(\enrol_lti\helper::ENROLMENT_NOT_STARTED, $result);
 135          $this->assertEquals(0, $DB->count_records('user_enrolments', array('enrolid' => $tool->enrolid)));
 136      }
 137  
 138      /**
 139       * Test that we can not enrol when the enrolment has finished.
 140       */
 141      public function test_enrol_user_enrolment_finished() {
 142          global $DB;
 143  
 144          // Set up the LTI enrolment tool.
 145          $data = new stdClass();
 146          $data->enrolenddate = time() - DAYSECS; // Make sure it is in the past.
 147          $tool = $this->create_tool($data);
 148  
 149          // Now get all the information we need.
 150          $tool = \enrol_lti\helper::get_lti_tool($tool->id);
 151  
 152          // Try and enrol a user - should not happen.
 153          $result = \enrol_lti\helper::enrol_user($tool, $this->user1->id);
 154  
 155          // Check that this user was not enrolled and we are told why.
 156          $this->assertEquals(\enrol_lti\helper::ENROLMENT_FINISHED, $result);
 157          $this->assertEquals(0, $DB->count_records('user_enrolments', array('enrolid' => $tool->enrolid)));
 158      }
 159  
 160      /**
 161       * Test returning the number of available tools.
 162       */
 163      public function test_count_lti_tools() {
 164          // Create two tools belonging to the same course.
 165          $course1 = $this->getDataGenerator()->create_course();
 166          $data = new stdClass();
 167          $data->courseid = $course1->id;
 168          $this->create_tool($data);
 169          $this->create_tool($data);
 170  
 171          // Create two more tools in a separate course.
 172          $course2 = $this->getDataGenerator()->create_course();
 173          $data = new stdClass();
 174          $data->courseid = $course2->id;
 175          $this->create_tool($data);
 176  
 177          // Set the next tool to disabled.
 178          $data->status = ENROL_INSTANCE_DISABLED;
 179          $this->create_tool($data);
 180  
 181          // Count all the tools.
 182          $count = \enrol_lti\helper::count_lti_tools();
 183          $this->assertEquals(4, $count);
 184  
 185          // Count all the tools in course 1.
 186          $count = \enrol_lti\helper::count_lti_tools(array('courseid' => $course1->id));
 187          $this->assertEquals(2, $count);
 188  
 189          // Count all the tools in course 2 that are disabled.
 190          $count = \enrol_lti\helper::count_lti_tools(array('courseid' => $course2->id, 'status' => ENROL_INSTANCE_DISABLED));
 191          $this->assertEquals(1, $count);
 192  
 193          // Count all the tools that are enabled.
 194          $count = \enrol_lti\helper::count_lti_tools(array('status' => ENROL_INSTANCE_ENABLED));
 195          $this->assertEquals(3, $count);
 196      }
 197  
 198      /**
 199       * Test returning the list of available tools.
 200       */
 201      public function test_get_lti_tools() {
 202          // Create two tools belonging to the same course.
 203          $course1 = $this->getDataGenerator()->create_course();
 204          $data = new stdClass();
 205          $data->courseid = $course1->id;
 206          $tool1 = $this->create_tool($data);
 207          $tool2 = $this->create_tool($data);
 208  
 209          // Create two more tools in a separate course.
 210          $course2 = $this->getDataGenerator()->create_course();
 211          $data = new stdClass();
 212          $data->courseid = $course2->id;
 213          $tool3 = $this->create_tool($data);
 214  
 215          // Set the next tool to disabled.
 216          $data->status = ENROL_INSTANCE_DISABLED;
 217          $tool4 = $this->create_tool($data);
 218  
 219          // Get all the tools.
 220          $tools = \enrol_lti\helper::get_lti_tools();
 221  
 222          // Check that we got all the tools.
 223          $this->assertEquals(4, count($tools));
 224  
 225          // Get all the tools in course 1.
 226          $tools = \enrol_lti\helper::get_lti_tools(array('courseid' => $course1->id));
 227  
 228          // Check that we got all the tools in course 1.
 229          $this->assertEquals(2, count($tools));
 230          $this->assertTrue(isset($tools[$tool1->id]));
 231          $this->assertTrue(isset($tools[$tool2->id]));
 232  
 233          // Get all the tools in course 2 that are disabled.
 234          $tools = \enrol_lti\helper::get_lti_tools(array('courseid' => $course2->id, 'status' => ENROL_INSTANCE_DISABLED));
 235  
 236          // Check that we got all the tools in course 2 that are disabled.
 237          $this->assertEquals(1, count($tools));
 238          $this->assertTrue(isset($tools[$tool4->id]));
 239  
 240          // Get all the tools that are enabled.
 241          $tools = \enrol_lti\helper::get_lti_tools(array('status' => ENROL_INSTANCE_ENABLED));
 242  
 243          // Check that we got all the tools that are enabled.
 244          $this->assertEquals(3, count($tools));
 245          $this->assertTrue(isset($tools[$tool1->id]));
 246          $this->assertTrue(isset($tools[$tool2->id]));
 247          $this->assertTrue(isset($tools[$tool3->id]));
 248      }
 249  
 250      /**
 251       * Helper function used to create a tool.
 252       *
 253       * @param array $data
 254       * @return stdClass the tool
 255       */
 256      protected function create_tool($data = array()) {
 257          global $DB;
 258  
 259          $studentrole = $DB->get_record('role', array('shortname' => 'student'));
 260          $teacherrole = $DB->get_record('role', array('shortname' => 'teacher'));
 261  
 262          // Create a course if no course id was specified.
 263          if (empty($data->courseid)) {
 264              $course = $this->getDataGenerator()->create_course();
 265              $data->courseid = $course->id;
 266          } else {
 267              $course = get_course($data->courseid);
 268          }
 269  
 270          // Set it to enabled if no status was specified.
 271          if (!isset($data->status)) {
 272              $data->status = ENROL_INSTANCE_ENABLED;
 273          }
 274  
 275          // Add some extra necessary fields to the data.
 276          $data->name = 'Test LTI';
 277          $data->contextid = context_course::instance($data->courseid)->id;
 278          $data->roleinstructor = $studentrole->id;
 279          $data->rolelearner = $teacherrole->id;
 280  
 281          // Get the enrol LTI plugin.
 282          $enrolplugin = enrol_get_plugin('lti');
 283          $instanceid = $enrolplugin->add_instance($course, (array) $data);
 284  
 285          // Get the tool associated with this instance.
 286          return $DB->get_record('enrol_lti_tools', array('enrolid' => $instanceid));
 287      }
 288  }