[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   * External completion functions unit tests
  19   *
  20   * @package    core_completion
  21   * @category   external
  22   * @copyright  2015 Juan Leyva <juan@moodle.com>
  23   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24   * @since      Moodle 2.9
  25   */
  26  
  27  defined('MOODLE_INTERNAL') || die();
  28  
  29  global $CFG;
  30  
  31  require_once($CFG->dirroot . '/webservice/tests/helpers.php');
  32  
  33  /**
  34   * External completion functions unit tests
  35   *
  36   * @package    core_completion
  37   * @category   external
  38   * @copyright  2015 Juan Leyva <juan@moodle.com>
  39   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  40   * @since      Moodle 2.9
  41   */
  42  class core_completion_externallib_testcase extends externallib_advanced_testcase {
  43  
  44      /**
  45       * Test update_activity_completion_status_manually
  46       */
  47      public function test_update_activity_completion_status_manually() {
  48          global $DB, $CFG;
  49  
  50          $this->resetAfterTest(true);
  51  
  52          $CFG->enablecompletion = true;
  53          $user = $this->getDataGenerator()->create_user();
  54          $course = $this->getDataGenerator()->create_course(array('enablecompletion' => 1));
  55          $data = $this->getDataGenerator()->create_module('data', array('course' => $course->id),
  56                                                               array('completion' => 1));
  57          $cm = get_coursemodule_from_id('data', $data->cmid);
  58  
  59          $studentrole = $DB->get_record('role', array('shortname' => 'student'));
  60          $this->getDataGenerator()->enrol_user($user->id, $course->id, $studentrole->id);
  61  
  62          $this->setUser($user);
  63  
  64          $result = core_completion_external::update_activity_completion_status_manually($data->cmid, true);
  65          // We need to execute the return values cleaning process to simulate the web service server.
  66          $result = external_api::clean_returnvalue(
  67              core_completion_external::update_activity_completion_status_manually_returns(), $result);
  68  
  69          // Check in DB.
  70          $this->assertEquals(1, $DB->get_field('course_modules_completion', 'completionstate',
  71                              array('coursemoduleid' => $data->cmid)));
  72  
  73          // Check using the API.
  74          $completion = new completion_info($course);
  75          $completiondata = $completion->get_data($cm);
  76          $this->assertEquals(1, $completiondata->completionstate);
  77          $this->assertTrue($result['status']);
  78  
  79          $result = core_completion_external::update_activity_completion_status_manually($data->cmid, false);
  80          // We need to execute the return values cleaning process to simulate the web service server.
  81          $result = external_api::clean_returnvalue(
  82              core_completion_external::update_activity_completion_status_manually_returns(), $result);
  83  
  84          $this->assertEquals(0, $DB->get_field('course_modules_completion', 'completionstate',
  85                              array('coursemoduleid' => $data->cmid)));
  86          $completiondata = $completion->get_data($cm);
  87          $this->assertEquals(0, $completiondata->completionstate);
  88          $this->assertTrue($result['status']);
  89      }
  90  
  91      /**
  92       * Test update_activity_completion_status
  93       */
  94      public function test_get_activities_completion_status() {
  95          global $DB, $CFG;
  96  
  97          $this->resetAfterTest(true);
  98  
  99          $CFG->enablecompletion = true;
 100          $student = $this->getDataGenerator()->create_user();
 101          $teacher = $this->getDataGenerator()->create_user();
 102  
 103          $course = $this->getDataGenerator()->create_course(array('enablecompletion' => 1,
 104                                                                      'groupmode' => SEPARATEGROUPS,
 105                                                                      'groupmodeforce' => 1));
 106  
 107          $data = $this->getDataGenerator()->create_module('data', array('course' => $course->id),
 108                                                               array('completion' => 1));
 109          $forum = $this->getDataGenerator()->create_module('forum',  array('course' => $course->id),
 110                                                               array('completion' => 1));
 111          $assign = $this->getDataGenerator()->create_module('assign',  array('course' => $course->id));
 112          $page = $this->getDataGenerator()->create_module('page',  array('course' => $course->id),
 113                                                              array('completion' => 1, 'visible' => 0));
 114  
 115          $cmdata = get_coursemodule_from_id('data', $data->cmid);
 116          $cmforum = get_coursemodule_from_id('forum', $forum->cmid);
 117  
 118          $studentrole = $DB->get_record('role', array('shortname' => 'student'));
 119          $teacherrole = $DB->get_record('role', array('shortname' => 'teacher'));
 120          $this->getDataGenerator()->enrol_user($student->id, $course->id, $studentrole->id);
 121          $this->getDataGenerator()->enrol_user($teacher->id, $course->id, $teacherrole->id);
 122  
 123          $group1 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
 124          $group2 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
 125  
 126          // Teacher and student in different groups initially.
 127          groups_add_member($group1->id, $student->id);
 128          groups_add_member($group2->id, $teacher->id);
 129  
 130          $this->setUser($student);
 131          // Forum complete.
 132          $completion = new completion_info($course);
 133          $completion->update_state($cmforum, COMPLETION_COMPLETE);
 134  
 135          $result = core_completion_external::get_activities_completion_status($course->id, $student->id);
 136          // We need to execute the return values cleaning process to simulate the web service server.
 137          $result = external_api::clean_returnvalue(
 138              core_completion_external::get_activities_completion_status_returns(), $result);
 139  
 140          // We added 4 activities, but only 3 with completion enabled and one of those is hidden.
 141          $this->assertCount(2, $result['statuses']);
 142  
 143          $activitiesfound = 0;
 144          foreach ($result['statuses'] as $status) {
 145              if ($status['cmid'] == $forum->cmid and $status['modname'] == 'forum' and $status['instance'] == $forum->id) {
 146                  $activitiesfound++;
 147                  $this->assertEquals(COMPLETION_COMPLETE, $status['state']);
 148                  $this->assertEquals(COMPLETION_TRACKING_MANUAL, $status['tracking']);
 149              } else if ($status['cmid'] == $data->cmid and $status['modname'] == 'data' and $status['instance'] == $data->id) {
 150                  $activitiesfound++;
 151                  $this->assertEquals(COMPLETION_INCOMPLETE, $status['state']);
 152                  $this->assertEquals(COMPLETION_TRACKING_MANUAL, $status['tracking']);
 153              }
 154          }
 155          $this->assertEquals(2, $activitiesfound);
 156  
 157          // Teacher should see students status, they are in different groups but the teacher can access all groups.
 158          $this->setUser($teacher);
 159          $result = core_completion_external::get_activities_completion_status($course->id, $student->id);
 160          // We need to execute the return values cleaning process to simulate the web service server.
 161          $result = external_api::clean_returnvalue(
 162              core_completion_external::get_activities_completion_status_returns(), $result);
 163  
 164          // We added 4 activities, but only 3 with completion enabled and one of those is hidden.
 165          $this->assertCount(3, $result['statuses']);
 166  
 167          // Change teacher role capabilities (disable access al goups).
 168          $context = context_course::instance($course->id);
 169          assign_capability('moodle/site:accessallgroups', CAP_PROHIBIT, $teacherrole->id, $context);
 170          accesslib_clear_all_caches_for_unit_testing();
 171  
 172          try {
 173              $result = core_completion_external::get_activities_completion_status($course->id, $student->id);
 174              $this->fail('Exception expected due to groups permissions.');
 175          } catch (moodle_exception $e) {
 176              $this->assertEquals('accessdenied', $e->errorcode);
 177          }
 178  
 179          // Now add the teacher in the same group.
 180          groups_add_member($group1->id, $teacher->id);
 181          $result = core_completion_external::get_activities_completion_status($course->id, $student->id);
 182          // We need to execute the return values cleaning process to simulate the web service server.
 183          $result = external_api::clean_returnvalue(
 184              core_completion_external::get_activities_completion_status_returns(), $result);
 185          // We added 4 activities, but only 3 with completion enabled and one of those is hidden.
 186          $this->assertCount(3, $result['statuses']);
 187      }
 188  
 189      /**
 190       * Test get_course_completion_status
 191       */
 192      public function test_get_course_completion_status() {
 193          global $DB, $CFG, $COMPLETION_CRITERIA_TYPES;
 194          require_once($CFG->dirroot.'/completion/criteria/completion_criteria_self.php');
 195          require_once($CFG->dirroot.'/completion/criteria/completion_criteria_date.php');
 196          require_once($CFG->dirroot.'/completion/criteria/completion_criteria_unenrol.php');
 197          require_once($CFG->dirroot.'/completion/criteria/completion_criteria_activity.php');
 198          require_once($CFG->dirroot.'/completion/criteria/completion_criteria_duration.php');
 199          require_once($CFG->dirroot.'/completion/criteria/completion_criteria_grade.php');
 200          require_once($CFG->dirroot.'/completion/criteria/completion_criteria_role.php');
 201          require_once($CFG->dirroot.'/completion/criteria/completion_criteria_course.php');
 202  
 203          $this->resetAfterTest(true);
 204  
 205          $CFG->enablecompletion = true;
 206          $student = $this->getDataGenerator()->create_user();
 207          $teacher = $this->getDataGenerator()->create_user();
 208  
 209          $course = $this->getDataGenerator()->create_course(array('enablecompletion' => 1,
 210                                                                      'groupmode' => SEPARATEGROUPS,
 211                                                                      'groupmodeforce' => 1));
 212  
 213          $data = $this->getDataGenerator()->create_module('data', array('course' => $course->id),
 214                                                               array('completion' => 1));
 215          $forum = $this->getDataGenerator()->create_module('forum',  array('course' => $course->id),
 216                                                               array('completion' => 1));
 217          $assign = $this->getDataGenerator()->create_module('assign',  array('course' => $course->id));
 218  
 219          $cmdata = get_coursemodule_from_id('data', $data->cmid);
 220          $cmforum = get_coursemodule_from_id('forum', $forum->cmid);
 221  
 222          $studentrole = $DB->get_record('role', array('shortname' => 'student'));
 223          $teacherrole = $DB->get_record('role', array('shortname' => 'teacher'));
 224          $this->getDataGenerator()->enrol_user($student->id, $course->id, $studentrole->id);
 225          $this->getDataGenerator()->enrol_user($teacher->id, $course->id, $teacherrole->id);
 226  
 227          $group1 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
 228          $group2 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
 229          // Teacher and student in different groups initially.
 230          groups_add_member($group1->id, $student->id);
 231          groups_add_member($group2->id, $teacher->id);
 232  
 233          // Set completion rules.
 234          $completion = new completion_info($course);
 235  
 236          // Loop through each criteria type and run its update_config() method.
 237  
 238          $criteriadata = new stdClass();
 239          $criteriadata->id = $course->id;
 240          $criteriadata->criteria_activity = array();
 241          // Some activities.
 242          $criteriadata->criteria_activity[$cmdata->id] = 1;
 243          $criteriadata->criteria_activity[$cmforum->id] = 1;
 244  
 245          // In a week criteria date value.
 246          $criteriadata->criteria_date_value = time() + WEEKSECS;
 247  
 248          // Self completion.
 249          $criteriadata->criteria_self = 1;
 250  
 251          foreach ($COMPLETION_CRITERIA_TYPES as $type) {
 252              $class = 'completion_criteria_'.$type;
 253              $criterion = new $class();
 254              $criterion->update_config($criteriadata);
 255          }
 256  
 257          // Handle overall aggregation.
 258          $aggdata = array(
 259              'course'        => $course->id,
 260              'criteriatype'  => null
 261          );
 262          $aggregation = new completion_aggregation($aggdata);
 263          $aggregation->setMethod(COMPLETION_AGGREGATION_ALL);
 264          $aggregation->save();
 265  
 266          $aggdata['criteriatype'] = COMPLETION_CRITERIA_TYPE_ACTIVITY;
 267          $aggregation = new completion_aggregation($aggdata);
 268          $aggregation->setMethod(COMPLETION_AGGREGATION_ALL);
 269          $aggregation->save();
 270  
 271          $this->setUser($student);
 272  
 273          $result = core_completion_external::get_course_completion_status($course->id, $student->id);
 274          // We need to execute the return values cleaning process to simulate the web service server.
 275          $studentresult = external_api::clean_returnvalue(
 276              core_completion_external::get_course_completion_status_returns(), $result);
 277  
 278          // 3 different criteria.
 279          $this->assertCount(3, $studentresult['completionstatus']['completions']);
 280  
 281          $this->assertEquals(COMPLETION_AGGREGATION_ALL, $studentresult['completionstatus']['aggregation']);
 282          $this->assertFalse($studentresult['completionstatus']['completed']);
 283  
 284          $this->assertEquals('No', $studentresult['completionstatus']['completions'][0]['status']);
 285          $this->assertEquals('No', $studentresult['completionstatus']['completions'][1]['status']);
 286          $this->assertEquals('No', $studentresult['completionstatus']['completions'][2]['status']);
 287  
 288          // Teacher should see students status, they are in different groups but the teacher can access all groups.
 289          $this->setUser($teacher);
 290          $result = core_completion_external::get_course_completion_status($course->id, $student->id);
 291          // We need to execute the return values cleaning process to simulate the web service server.
 292          $teacherresult = external_api::clean_returnvalue(
 293              core_completion_external::get_course_completion_status_returns(), $result);
 294  
 295          $this->assertEquals($studentresult, $teacherresult);
 296  
 297          // Change teacher role capabilities (disable access al goups).
 298          $context = context_course::instance($course->id);
 299          assign_capability('moodle/site:accessallgroups', CAP_PROHIBIT, $teacherrole->id, $context);
 300          accesslib_clear_all_caches_for_unit_testing();
 301  
 302          try {
 303              $result = core_completion_external::get_course_completion_status($course->id, $student->id);
 304              $this->fail('Exception expected due to groups permissions.');
 305          } catch (moodle_exception $e) {
 306              $this->assertEquals('accessdenied', $e->errorcode);
 307          }
 308  
 309          // Now add the teacher in the same group.
 310          groups_add_member($group1->id, $teacher->id);
 311          $result = core_completion_external::get_course_completion_status($course->id, $student->id);
 312          // We need to execute the return values cleaning process to simulate the web service server.
 313          $teacherresult = external_api::clean_returnvalue(
 314              core_completion_external::get_course_completion_status_returns(), $result);
 315  
 316          $this->assertEquals($studentresult, $teacherresult);
 317  
 318      }
 319  
 320      /**
 321       * Test mark_course_self_completed
 322       */
 323      public function test_mark_course_self_completed() {
 324          global $DB, $CFG;
 325          require_once($CFG->dirroot.'/completion/criteria/completion_criteria_self.php');
 326  
 327          $this->resetAfterTest(true);
 328  
 329          $CFG->enablecompletion = true;
 330          $student = $this->getDataGenerator()->create_user();
 331          $teacher = $this->getDataGenerator()->create_user();
 332  
 333          $course = $this->getDataGenerator()->create_course(array('enablecompletion' => 1));
 334  
 335          $studentrole = $DB->get_record('role', array('shortname' => 'student'));
 336          $this->getDataGenerator()->enrol_user($student->id, $course->id, $studentrole->id);
 337  
 338          // Set completion rules.
 339          $completion = new completion_info($course);
 340  
 341          $criteriadata = new stdClass();
 342          $criteriadata->id = $course->id;
 343          $criteriadata->criteria_activity = array();
 344  
 345          // Self completion.
 346          $criteriadata->criteria_self = COMPLETION_CRITERIA_TYPE_SELF;
 347          $class = 'completion_criteria_self';
 348          $criterion = new $class();
 349          $criterion->update_config($criteriadata);
 350  
 351          // Handle overall aggregation.
 352          $aggdata = array(
 353              'course'        => $course->id,
 354              'criteriatype'  => null
 355          );
 356          $aggregation = new completion_aggregation($aggdata);
 357          $aggregation->setMethod(COMPLETION_AGGREGATION_ALL);
 358          $aggregation->save();
 359  
 360          $this->setUser($student);
 361  
 362          $result = core_completion_external::mark_course_self_completed($course->id);
 363          // We need to execute the return values cleaning process to simulate the web service server.
 364          $result = external_api::clean_returnvalue(
 365              core_completion_external::mark_course_self_completed_returns(), $result);
 366  
 367          // We expect a valid result.
 368          $this->assertEquals(true, $result['status']);
 369  
 370          $result = core_completion_external::get_course_completion_status($course->id, $student->id);
 371          // We need to execute the return values cleaning process to simulate the web service server.
 372          $result = external_api::clean_returnvalue(
 373              core_completion_external::get_course_completion_status_returns(), $result);
 374  
 375          // Course must be completed.
 376          $this->assertEquals(COMPLETION_COMPLETE, $result['completionstatus']['completions'][0]['complete']);
 377  
 378          try {
 379              $result = core_completion_external::mark_course_self_completed($course->id);
 380              $this->fail('Exception expected due course already self completed.');
 381          } catch (moodle_exception $e) {
 382              $this->assertEquals('useralreadymarkedcomplete', $e->errorcode);
 383          }
 384  
 385      }
 386  
 387  }