completion/tests/externallib_test.php

   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         availability_completion\condition::wipe_static_cache();
 107
 108         $data = $this->getDataGenerator()->create_module('data', array('course' => $course->id),
 109                                                              array('completion' => 1));
 110         $forum = $this->getDataGenerator()->create_module('forum',  array('course' => $course->id),
 111                                                              array('completion' => 1));
 112         $availability = '{"op":"&","c":[{"type":"completion","cm":' . $forum->cmid .',"e":1}],"showc":[true]}';
 113         $assign = $this->getDataGenerator()->create_module('assign', ['course' => $course->id], ['availability' => $availability]);
 114         $page = $this->getDataGenerator()->create_module('page',  array('course' => $course->id),
 115                                                             array('completion' => 1, 'visible' => 0));
 116
 117         $cmdata = get_coursemodule_from_id('data', $data->cmid);
 118         $cmforum = get_coursemodule_from_id('forum', $forum->cmid);
 119
 120         $studentrole = $DB->get_record('role', array('shortname' => 'student'));
 121         $teacherrole = $DB->get_record('role', array('shortname' => 'editingteacher'));
 122         $this->getDataGenerator()->enrol_user($student->id, $course->id, $studentrole->id);
 123         $this->getDataGenerator()->enrol_user($teacher->id, $course->id, $teacherrole->id);
 124
 125         $group1 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
 126         $group2 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
 127
 128         // Teacher and student in different groups initially.
 129         groups_add_member($group1->id, $student->id);
 130         groups_add_member($group2->id, $teacher->id);
 131
 132         $this->setUser($student);
 133         // Forum complete.
 134         $completion = new completion_info($course);
 135         $completion->update_state($cmforum, COMPLETION_COMPLETE);
 136
 137         $result = core_completion_external::get_activities_completion_status($course->id, $student->id);
 138         // We need to execute the return values cleaning process to simulate the web service server.
 139         $result = external_api::clean_returnvalue(
 140             core_completion_external::get_activities_completion_status_returns(), $result);
 141
 142         // We added 4 activities, but only 3 with completion enabled and one of those is hidden.
 143         $this->assertCount(2, $result['statuses']);
 144
 145         $activitiesfound = 0;
 146         foreach ($result['statuses'] as $status) {
 147             if ($status['cmid'] == $forum->cmid and $status['modname'] == 'forum' and $status['instance'] == $forum->id) {
 148                 $activitiesfound++;
 149                 $this->assertEquals(COMPLETION_COMPLETE, $status['state']);
 150                 $this->assertEquals(COMPLETION_TRACKING_MANUAL, $status['tracking']);
 151                 $this->assertTrue($status['valueused']);
 152             } else if ($status['cmid'] == $data->cmid and $status['modname'] == 'data' and $status['instance'] == $data->id) {
 153                 $activitiesfound++;
 154                 $this->assertEquals(COMPLETION_INCOMPLETE, $status['state']);
 155                 $this->assertEquals(COMPLETION_TRACKING_MANUAL, $status['tracking']);
 156                 $this->assertFalse($status['valueused']);
 157             }
 158         }
 159         $this->assertEquals(2, $activitiesfound);
 160
 161         // Teacher should see students status, they are in different groups but the teacher can access all groups.
 162         $this->setUser($teacher);
 163         $result = core_completion_external::get_activities_completion_status($course->id, $student->id);
 164         // We need to execute the return values cleaning process to simulate the web service server.
 165         $result = external_api::clean_returnvalue(
 166             core_completion_external::get_activities_completion_status_returns(), $result);
 167
 168         // We added 4 activities, but only 3 with completion enabled and one of those is hidden.
 169         $this->assertCount(3, $result['statuses']);
 170
 171         // Override status by teacher.
 172         $completion->update_state($cmforum, COMPLETION_INCOMPLETE, $student->id, true);
 173
 174         $result = core_completion_external::get_activities_completion_status($course->id, $student->id);
 175         // We need to execute the return values cleaning process to simulate the web service server.
 176         $result = external_api::clean_returnvalue(
 177             core_completion_external::get_activities_completion_status_returns(), $result);
 178
 179         // Check forum has been overriden by the teacher.
 180         foreach ($result['statuses'] as $status) {
 181             if ($status['cmid'] == $forum->cmid) {
 182                 $this->assertEquals(COMPLETION_INCOMPLETE, $status['state']);
 183                 $this->assertEquals(COMPLETION_TRACKING_MANUAL, $status['tracking']);
 184                 $this->assertEquals($teacher->id, $status['overrideby']);
 185                 break;
 186             }
 187         }
 188
 189         // Teacher should see his own completion status.
 190
 191         // Forum complete for teacher.
 192         $completion = new completion_info($course);
 193         $completion->update_state($cmforum, COMPLETION_COMPLETE);
 194
 195         $result = core_completion_external::get_activities_completion_status($course->id, $teacher->id);
 196         // We need to execute the return values cleaning process to simulate the web service server.
 197         $result = external_api::clean_returnvalue(
 198             core_completion_external::get_activities_completion_status_returns(), $result);
 199
 200         // We added 4 activities, but only 3 with completion enabled (one of those is hidden but the teacher can see it).
 201         $this->assertCount(3, $result['statuses']);
 202
 203         $activitiesfound = 0;
 204         foreach ($result['statuses'] as $status) {
 205             if ($status['cmid'] == $forum->cmid and $status['modname'] == 'forum' and $status['instance'] == $forum->id) {
 206                 $activitiesfound++;
 207                 $this->assertEquals(COMPLETION_COMPLETE, $status['state']);
 208                 $this->assertEquals(COMPLETION_TRACKING_MANUAL, $status['tracking']);
 209             } else {
 210                 $activitiesfound++;
 211                 $this->assertEquals(COMPLETION_INCOMPLETE, $status['state']);
 212                 $this->assertEquals(COMPLETION_TRACKING_MANUAL, $status['tracking']);
 213             }
 214         }
 215         $this->assertEquals(3, $activitiesfound);
 216
 217         // Change teacher role capabilities (disable access all groups).
 218         $context = context_course::instance($course->id);
 219         assign_capability('moodle/site:accessallgroups', CAP_PROHIBIT, $teacherrole->id, $context);
 220         accesslib_clear_all_caches_for_unit_testing();
 221
 222         try {
 223             $result = core_completion_external::get_activities_completion_status($course->id, $student->id);
 224             $this->fail('Exception expected due to groups permissions.');
 225         } catch (moodle_exception $e) {
 226             $this->assertEquals('accessdenied', $e->errorcode);
 227         }
 228
 229         // Now add the teacher in the same group.
 230         groups_add_member($group1->id, $teacher->id);
 231         $result = core_completion_external::get_activities_completion_status($course->id, $student->id);
 232         // We need to execute the return values cleaning process to simulate the web service server.
 233         $result = external_api::clean_returnvalue(
 234             core_completion_external::get_activities_completion_status_returns(), $result);
 235         // We added 4 activities, but only 3 with completion enabled and one of those is hidden.
 236         $this->assertCount(3, $result['statuses']);
 237     }
 238
 239     /**
 240      * Test override_activity_completion_status
 241      */
 242     public function test_override_activity_completion_status() {
 243         global $DB, $CFG;
 244         $this->resetAfterTest(true);
 245
 246         // Create course with teacher and student enrolled.
 247         $CFG->enablecompletion = true;
 248         $course  = $this->getDataGenerator()->create_course(['enablecompletion' => 1]);
 249         $student = $this->getDataGenerator()->create_user();
 250         $teacher = $this->getDataGenerator()->create_user();
 251         $studentrole = $DB->get_record('role', ['shortname' => 'student']);
 252         $this->getDataGenerator()->enrol_user($student->id, $course->id, $studentrole->id);
 253         $teacherrole = $DB->get_record('role', ['shortname' => 'teacher']);
 254         $this->getDataGenerator()->enrol_user($teacher->id, $course->id, $teacherrole->id);
 255
 256         // Create 2 activities, one with manual completion (data), one with automatic completion triggered by viewing it (forum).
 257         $data    = $this->getDataGenerator()->create_module('data', ['course' => $course->id], ['completion' => 1]);
 258         $forum   = $this->getDataGenerator()->create_module('forum',  ['course' => $course->id],
 259                                                             ['completion' => 2, 'completionview' => 1]);
 260         $cmdata = get_coursemodule_from_id('data', $data->cmid);
 261         $cmforum = get_coursemodule_from_id('forum', $forum->cmid);
 262
 263         // Manually complete the data activity as the student.
 264         $this->setUser($student);
 265         $completion = new completion_info($course);
 266         $completion->update_state($cmdata, COMPLETION_COMPLETE);
 267
 268         // Test overriding the status of the manual-completion-activity 'incomplete'.
 269         $this->setUser($teacher);
 270         $result = core_completion_external::override_activity_completion_status($student->id, $data->cmid, COMPLETION_INCOMPLETE);
 271         $result = external_api::clean_returnvalue(core_completion_external::override_activity_completion_status_returns(), $result);
 272         $this->assertEquals($result['state'], COMPLETION_INCOMPLETE);
 273         $completiondata = $completion->get_data($cmdata, false, $student->id);
 274         $this->assertEquals(COMPLETION_INCOMPLETE, $completiondata->completionstate);
 275
 276         // Test overriding the status of the manual-completion-activity back to 'complete'.
 277         $result = core_completion_external::override_activity_completion_status($student->id, $data->cmid, COMPLETION_COMPLETE);
 278         $result = external_api::clean_returnvalue(core_completion_external::override_activity_completion_status_returns(), $result);
 279         $this->assertEquals($result['state'], COMPLETION_COMPLETE);
 280         $completiondata = $completion->get_data($cmdata, false, $student->id);
 281         $this->assertEquals(COMPLETION_COMPLETE, $completiondata->completionstate);
 282
 283         // Test overriding the status of the auto-completion-activity to 'complete'.
 284         $result = core_completion_external::override_activity_completion_status($student->id, $forum->cmid, COMPLETION_COMPLETE);
 285         $result = external_api::clean_returnvalue(core_completion_external::override_activity_completion_status_returns(), $result);
 286         $this->assertEquals($result['state'], COMPLETION_COMPLETE);
 287         $completionforum = $completion->get_data($cmforum, false, $student->id);
 288         $this->assertEquals(COMPLETION_COMPLETE, $completionforum->completionstate);
 289
 290         // Test overriding the status of the auto-completion-activity to 'incomplete'.
 291         $result = core_completion_external::override_activity_completion_status($student->id, $forum->cmid, COMPLETION_INCOMPLETE);
 292         $result = external_api::clean_returnvalue(core_completion_external::override_activity_completion_status_returns(), $result);
 293         $this->assertEquals($result['state'], COMPLETION_INCOMPLETE);
 294         $completionforum = $completion->get_data($cmforum, false, $student->id);
 295         $this->assertEquals(COMPLETION_INCOMPLETE, $completionforum->completionstate);
 296
 297         // Test overriding the status of the auto-completion-activity to an invalid state.
 298         $this->expectException('moodle_exception');
 299         core_completion_external::override_activity_completion_status($student->id, $forum->cmid, 3);
 300     }
 301
 302     /**
 303      * Test overriding the activity completion status as a user without the capability to do so.
 304      */
 305     public function test_override_status_user_without_capability() {
 306         global $DB, $CFG;
 307         $this->resetAfterTest(true);
 308
 309         // Create course with teacher and student enrolled.
 310         $CFG->enablecompletion = true;
 311         $course  = $this->getDataGenerator()->create_course(['enablecompletion' => 1]);
 312         $student = $this->getDataGenerator()->create_user();
 313         $teacher = $this->getDataGenerator()->create_user();
 314         $studentrole = $DB->get_record('role', ['shortname' => 'student']);
 315         $this->getDataGenerator()->enrol_user($student->id, $course->id, $studentrole->id);
 316         $teacherrole = $DB->get_record('role', ['shortname' => 'teacher']);
 317         $this->getDataGenerator()->enrol_user($teacher->id, $course->id, $teacherrole->id);
 318         $coursecontext = context_course::instance($course->id);
 319
 320         // Create an activity with automatic completion (a forum).
 321         $forum   = $this->getDataGenerator()->create_module('forum',  ['course' => $course->id],
 322             ['completion' => 2, 'completionview' => 1]);
 323
 324         // Test overriding the status of the activity for a user without the capability.
 325         $this->setUser($teacher);
 326         assign_capability('moodle/course:overridecompletion', CAP_PREVENT, $teacherrole->id, $coursecontext);
 327         $this->expectException('required_capability_exception');
 328         core_completion_external::override_activity_completion_status($student->id, $forum->cmid, COMPLETION_COMPLETE);
 329     }
 330
 331     /**
 332      * Test get_course_completion_status
 333      */
 334     public function test_get_course_completion_status() {
 335         global $DB, $CFG, $COMPLETION_CRITERIA_TYPES;
 336         require_once($CFG->dirroot.'/completion/criteria/completion_criteria_self.php');
 337         require_once($CFG->dirroot.'/completion/criteria/completion_criteria_date.php');
 338         require_once($CFG->dirroot.'/completion/criteria/completion_criteria_unenrol.php');
 339         require_once($CFG->dirroot.'/completion/criteria/completion_criteria_activity.php');
 340         require_once($CFG->dirroot.'/completion/criteria/completion_criteria_duration.php');
 341         require_once($CFG->dirroot.'/completion/criteria/completion_criteria_grade.php');
 342         require_once($CFG->dirroot.'/completion/criteria/completion_criteria_role.php');
 343         require_once($CFG->dirroot.'/completion/criteria/completion_criteria_course.php');
 344
 345         $this->resetAfterTest(true);
 346
 347         $CFG->enablecompletion = true;
 348         $student = $this->getDataGenerator()->create_user();
 349         $teacher = $this->getDataGenerator()->create_user();
 350
 351         $course = $this->getDataGenerator()->create_course(array('enablecompletion' => 1,
 352                                                                     'groupmode' => SEPARATEGROUPS,
 353                                                                     'groupmodeforce' => 1));
 354
 355         $data = $this->getDataGenerator()->create_module('data', array('course' => $course->id),
 356                                                              array('completion' => 1));
 357         $forum = $this->getDataGenerator()->create_module('forum',  array('course' => $course->id),
 358                                                              array('completion' => 1));
 359         $assign = $this->getDataGenerator()->create_module('assign',  array('course' => $course->id));
 360
 361         $cmdata = get_coursemodule_from_id('data', $data->cmid);
 362         $cmforum = get_coursemodule_from_id('forum', $forum->cmid);
 363
 364         $studentrole = $DB->get_record('role', array('shortname' => 'student'));
 365         $teacherrole = $DB->get_record('role', array('shortname' => 'editingteacher'));
 366         $this->getDataGenerator()->enrol_user($student->id, $course->id, $studentrole->id);
 367         $this->getDataGenerator()->enrol_user($teacher->id, $course->id, $teacherrole->id);
 368
 369         $group1 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
 370         $group2 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
 371         // Teacher and student in different groups initially.
 372         groups_add_member($group1->id, $student->id);
 373         groups_add_member($group2->id, $teacher->id);
 374
 375         // Set completion rules.
 376         $completion = new completion_info($course);
 377
 378         // Loop through each criteria type and run its update_config() method.
 379
 380         $criteriadata = new stdClass();
 381         $criteriadata->id = $course->id;
 382         $criteriadata->criteria_activity = array();
 383         // Some activities.
 384         $criteriadata->criteria_activity[$cmdata->id] = 1;
 385         $criteriadata->criteria_activity[$cmforum->id] = 1;
 386
 387         // In a week criteria date value.
 388         $criteriadata->criteria_date_value = time() + WEEKSECS;
 389
 390         // Self completion.
 391         $criteriadata->criteria_self = 1;
 392
 393         foreach ($COMPLETION_CRITERIA_TYPES as $type) {
 394             $class = 'completion_criteria_'.$type;
 395             $criterion = new $class();
 396             $criterion->update_config($criteriadata);
 397         }
 398
 399         // Handle overall aggregation.
 400         $aggdata = array(
 401             'course'        => $course->id,
 402             'criteriatype'  => null
 403         );
 404         $aggregation = new completion_aggregation($aggdata);
 405         $aggregation->setMethod(COMPLETION_AGGREGATION_ALL);
 406         $aggregation->save();
 407
 408         $aggdata['criteriatype'] = COMPLETION_CRITERIA_TYPE_ACTIVITY;
 409         $aggregation = new completion_aggregation($aggdata);
 410         $aggregation->setMethod(COMPLETION_AGGREGATION_ALL);
 411         $aggregation->save();
 412
 413         $this->setUser($student);
 414
 415         $result = core_completion_external::get_course_completion_status($course->id, $student->id);
 416         // We need to execute the return values cleaning process to simulate the web service server.
 417         $studentresult = external_api::clean_returnvalue(
 418             core_completion_external::get_course_completion_status_returns(), $result);
 419
 420         // 3 different criteria.
 421         $this->assertCount(3, $studentresult['completionstatus']['completions']);
 422
 423         $this->assertEquals(COMPLETION_AGGREGATION_ALL, $studentresult['completionstatus']['aggregation']);
 424         $this->assertFalse($studentresult['completionstatus']['completed']);
 425
 426         $this->assertEquals('No', $studentresult['completionstatus']['completions'][0]['status']);
 427         $this->assertEquals('No', $studentresult['completionstatus']['completions'][1]['status']);
 428         $this->assertEquals('No', $studentresult['completionstatus']['completions'][2]['status']);
 429
 430         // Teacher should see students status, they are in different groups but the teacher can access all groups.
 431         $this->setUser($teacher);
 432         $result = core_completion_external::get_course_completion_status($course->id, $student->id);
 433         // We need to execute the return values cleaning process to simulate the web service server.
 434         $teacherresult = external_api::clean_returnvalue(
 435             core_completion_external::get_course_completion_status_returns(), $result);
 436
 437         $this->assertEquals($studentresult, $teacherresult);
 438
 439         // Change teacher role capabilities (disable access al goups).
 440         $context = context_course::instance($course->id);
 441         assign_capability('moodle/site:accessallgroups', CAP_PROHIBIT, $teacherrole->id, $context);
 442         accesslib_clear_all_caches_for_unit_testing();
 443
 444         try {
 445             $result = core_completion_external::get_course_completion_status($course->id, $student->id);
 446             $this->fail('Exception expected due to groups permissions.');
 447         } catch (moodle_exception $e) {
 448             $this->assertEquals('accessdenied', $e->errorcode);
 449         }
 450
 451         // Now add the teacher in the same group.
 452         groups_add_member($group1->id, $teacher->id);
 453         $result = core_completion_external::get_course_completion_status($course->id, $student->id);
 454         // We need to execute the return values cleaning process to simulate the web service server.
 455         $teacherresult = external_api::clean_returnvalue(
 456             core_completion_external::get_course_completion_status_returns(), $result);
 457
 458         $this->assertEquals($studentresult, $teacherresult);
 459
 460     }
 461
 462     /**
 463      * Test mark_course_self_completed
 464      */
 465     public function test_mark_course_self_completed() {
 466         global $DB, $CFG;
 467         require_once($CFG->dirroot.'/completion/criteria/completion_criteria_self.php');
 468
 469         $this->resetAfterTest(true);
 470
 471         $CFG->enablecompletion = true;
 472         $student = $this->getDataGenerator()->create_user();
 473         $teacher = $this->getDataGenerator()->create_user();
 474
 475         $course = $this->getDataGenerator()->create_course(array('enablecompletion' => 1));
 476
 477         $studentrole = $DB->get_record('role', array('shortname' => 'student'));
 478         $this->getDataGenerator()->enrol_user($student->id, $course->id, $studentrole->id);
 479
 480         // Set completion rules.
 481         $completion = new completion_info($course);
 482
 483         $criteriadata = new stdClass();
 484         $criteriadata->id = $course->id;
 485         $criteriadata->criteria_activity = array();
 486
 487         // Self completion.
 488         $criteriadata->criteria_self = COMPLETION_CRITERIA_TYPE_SELF;
 489         $class = 'completion_criteria_self';
 490         $criterion = new $class();
 491         $criterion->update_config($criteriadata);
 492
 493         // Handle overall aggregation.
 494         $aggdata = array(
 495             'course'        => $course->id,
 496             'criteriatype'  => null
 497         );
 498         $aggregation = new completion_aggregation($aggdata);
 499         $aggregation->setMethod(COMPLETION_AGGREGATION_ALL);
 500         $aggregation->save();
 501
 502         $this->setUser($student);
 503
 504         $result = core_completion_external::mark_course_self_completed($course->id);
 505         // We need to execute the return values cleaning process to simulate the web service server.
 506         $result = external_api::clean_returnvalue(
 507             core_completion_external::mark_course_self_completed_returns(), $result);
 508
 509         // We expect a valid result.
 510         $this->assertEquals(true, $result['status']);
 511
 512         $result = core_completion_external::get_course_completion_status($course->id, $student->id);
 513         // We need to execute the return values cleaning process to simulate the web service server.
 514         $result = external_api::clean_returnvalue(
 515             core_completion_external::get_course_completion_status_returns(), $result);
 516
 517         // Course must be completed.
 518         $this->assertEquals(COMPLETION_COMPLETE, $result['completionstatus']['completions'][0]['complete']);
 519
 520         try {
 521             $result = core_completion_external::mark_course_self_completed($course->id);
 522             $this->fail('Exception expected due course already self completed.');
 523         } catch (moodle_exception $e) {
 524             $this->assertEquals('useralreadymarkedcomplete', $e->errorcode);
 525         }
 526
 527     }
 528
 529 }