lib/tests/grading_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 defined('MOODLE_INTERNAL') || die();
  18
  19 global $CFG;
  20
  21 require_once($CFG->dirroot . '/webservice/tests/helpers.php');
  22
  23 /**
  24  * Unit tests for the grading API defined in core_grading_external class.
  25  *
  26  * @package core_grading
  27  * @category external
  28  * @copyright 2013 Paul Charsley
  29  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  30  */
  31 class core_grading_externallib_testcase extends externallib_advanced_testcase {
  32
  33     /**
  34      * Test get_definitions
  35      */
  36     public function test_get_definitions() {
  37         global $DB, $CFG, $USER;
  38
  39         $this->resetAfterTest(true);
  40         // Create a course and assignment.
  41         $coursedata['idnumber'] = 'idnumbercourse';
  42         $coursedata['fullname'] = 'Lightwork Course';
  43         $coursedata['summary'] = 'Lightwork Course description';
  44         $coursedata['summaryformat'] = FORMAT_MOODLE;
  45         $course = self::getDataGenerator()->create_course($coursedata);
  46
  47         $assigndata['course'] = $course->id;
  48         $assigndata['name'] = 'lightwork assignment';
  49
  50         $cm = self::getDataGenerator()->create_module('assign', $assigndata);
  51
  52         // Create manual enrolment record.
  53         $manualenroldata['enrol'] = 'manual';
  54         $manualenroldata['status'] = 0;
  55         $manualenroldata['courseid'] = $course->id;
  56         $enrolid = $DB->insert_record('enrol', $manualenroldata);
  57
  58         // Create a teacher and give them capabilities.
  59         $coursecontext = context_course::instance($course->id);
  60         $roleid = $this->assignUserCapability('moodle/course:viewparticipants', $coursecontext->id, 3);
  61         $modulecontext = context_module::instance($cm->cmid);
  62         $this->assignUserCapability('mod/assign:grade', $modulecontext->id, $roleid);
  63
  64         // Create the teacher's enrolment record.
  65         $userenrolmentdata['status'] = 0;
  66         $userenrolmentdata['enrolid'] = $enrolid;
  67         $userenrolmentdata['userid'] = $USER->id;
  68         $DB->insert_record('user_enrolments', $userenrolmentdata);
  69
  70         // Create a grading area.
  71         $gradingarea = array(
  72             'contextid' => $modulecontext->id,
  73             'component' => 'mod_assign',
  74             'areaname' => 'submissions',
  75             'activemethod' => 'rubric'
  76         );
  77         $areaid = $DB->insert_record('grading_areas', $gradingarea);
  78
  79         // Create a rubric grading definition.
  80         $rubricdefinition = array (
  81             'areaid' => $areaid,
  82             'method' => 'rubric',
  83             'name' => 'test',
  84             'status' => 20,
  85             'copiedfromid' => 1,
  86             'timecreated' => 1,
  87             'usercreated' => $USER->id,
  88             'timemodified' => 1,
  89             'usermodified' => $USER->id,
  90             'timecopied' => 0
  91         );
  92         $definitionid = $DB->insert_record('grading_definitions', $rubricdefinition);
  93
  94         // Create a criterion with levels.
  95         $rubriccriteria1 = array (
  96             'definitionid' => $definitionid,
  97             'sortorder' => 1,
  98             'description' => 'Demonstrate an understanding of disease control',
  99             'descriptionformat' => 0
 100         );
 101         $criterionid1 = $DB->insert_record('gradingform_rubric_criteria', $rubriccriteria1);
 102         $rubriclevel1 = array (
 103             'criterionid' => $criterionid1,
 104             'score' => 5,
 105             'definition' => 'pass',
 106             'definitionformat' => 0
 107         );
 108         $DB->insert_record('gradingform_rubric_levels', $rubriclevel1);
 109         $rubriclevel2 = array (
 110             'criterionid' => $criterionid1,
 111             'score' => 10,
 112             'definition' => 'excellent',
 113             'definitionformat' => 0
 114         );
 115         $DB->insert_record('gradingform_rubric_levels', $rubriclevel2);
 116
 117         // Create a second criterion with levels.
 118         $rubriccriteria2 = array (
 119             'definitionid' => $definitionid,
 120             'sortorder' => 2,
 121             'description' => 'Demonstrate an understanding of brucellosis',
 122             'descriptionformat' => 0
 123         );
 124         $criterionid2 = $DB->insert_record('gradingform_rubric_criteria', $rubriccriteria2);
 125         $rubriclevel1 = array (
 126             'criterionid' => $criterionid2,
 127             'score' => 5,
 128             'definition' => 'pass',
 129             'definitionformat' => 0
 130         );
 131         $DB->insert_record('gradingform_rubric_levels', $rubriclevel1);
 132         $rubriclevel2 = array (
 133             'criterionid' => $criterionid2,
 134             'score' => 10,
 135             'definition' => 'excellent',
 136             'definitionformat' => 0
 137         );
 138         $DB->insert_record('gradingform_rubric_levels', $rubriclevel2);
 139
 140         // Call the external function.
 141         $cmids = array ($cm->cmid);
 142         $areaname = 'submissions';
 143         $result = core_grading_external::get_definitions($cmids, $areaname);
 144         $result = external_api::clean_returnvalue(core_grading_external::get_definitions_returns(), $result);
 145
 146         $this->assertEquals(1, count($result['areas']));
 147         $this->assertEquals(1, count($result['areas'][0]['definitions']));
 148         $definition = $result['areas'][0]['definitions'][0];
 149
 150         $this->assertEquals($rubricdefinition['method'], $definition['method']);
 151         $this->assertEquals($USER->id, $definition['usercreated']);
 152
 153         require_once("$CFG->dirroot/grade/grading/lib.php");
 154         require_once($CFG->dirroot.'/grade/grading/form/'.$rubricdefinition['method'].'/lib.php');
 155
 156         $gradingmanager = get_grading_manager($areaid);
 157
 158         $this->assertEquals(1, count($definition[$rubricdefinition['method']]));
 159
 160         $rubricdetails = $definition[$rubricdefinition['method']];
 161         $details = call_user_func('gradingform_'.$rubricdefinition['method'].'_controller::get_external_definition_details');
 162
 163         $this->assertEquals(2, count($rubricdetails[key($details)]));
 164
 165         $found = false;
 166         foreach ($rubricdetails[key($details)] as $criterion) {
 167             if ($criterion['id'] == $criterionid1) {
 168                 $this->assertEquals($rubriccriteria1['description'], $criterion['description']);
 169                 $this->assertEquals(2, count($criterion['levels']));
 170                 $found = true;
 171                 break;
 172             }
 173         }
 174         $this->assertTrue($found);
 175     }
 176
 177     /**
 178      * Test get_gradingform_instances
 179      */
 180     public function test_get_gradingform_instances() {
 181         global $DB, $USER;
 182
 183         $this->resetAfterTest(true);
 184         // Create a course and assignment.
 185         $coursedata['idnumber'] = 'idnumbercourse';
 186         $coursedata['fullname'] = 'Lightwork Course';
 187         $coursedata['summary'] = 'Lightwork Course description';
 188         $coursedata['summaryformat'] = FORMAT_MOODLE;
 189         $course = self::getDataGenerator()->create_course($coursedata);
 190
 191         $assigndata['course'] = $course->id;
 192         $assigndata['name'] = 'lightwork assignment';
 193
 194         $assign = self::getDataGenerator()->create_module('assign', $assigndata);
 195
 196         // Create manual enrolment record.
 197         $manualenroldata['enrol'] = 'manual';
 198         $manualenroldata['status'] = 0;
 199         $manualenroldata['courseid'] = $course->id;
 200         $enrolid = $DB->insert_record('enrol', $manualenroldata);
 201
 202         // Create a teacher and give them capabilities.
 203         $coursecontext = context_course::instance($course->id);
 204         $roleid = $this->assignUserCapability('moodle/course:viewparticipants', $coursecontext->id, 3);
 205         $modulecontext = context_module::instance($assign->cmid);
 206         $this->assignUserCapability('mod/assign:grade', $modulecontext->id, $roleid);
 207
 208         // Create the teacher's enrolment record.
 209         $userenrolmentdata['status'] = 0;
 210         $userenrolmentdata['enrolid'] = $enrolid;
 211         $userenrolmentdata['userid'] = $USER->id;
 212         $DB->insert_record('user_enrolments', $userenrolmentdata);
 213
 214         // Create a student with an assignment grade.
 215         $student = self::getDataGenerator()->create_user();
 216         $assigngrade = new stdClass();
 217         $assigngrade->assignment = $assign->id;
 218         $assigngrade->userid = $student->id;
 219         $assigngrade->timecreated = time();
 220         $assigngrade->timemodified = $assigngrade->timecreated;
 221         $assigngrade->grader = $USER->id;
 222         $assigngrade->grade = 50;
 223         $assigngrade->attemptnumber = 0;
 224         $gid = $DB->insert_record('assign_grades', $assigngrade);
 225
 226         // Create a grading area.
 227         $gradingarea = array(
 228             'contextid' => $modulecontext->id,
 229             'component' => 'mod_assign',
 230             'areaname' => 'submissions',
 231             'activemethod' => 'rubric'
 232         );
 233         $areaid = $DB->insert_record('grading_areas', $gradingarea);
 234
 235         // Create a rubric grading definition.
 236         $rubricdefinition = array (
 237             'areaid' => $areaid,
 238             'method' => 'rubric',
 239             'name' => 'test',
 240             'status' => 20,
 241             'copiedfromid' => 1,
 242             'timecreated' => 1,
 243             'usercreated' => $USER->id,
 244             'timemodified' => 1,
 245             'usermodified' => $USER->id,
 246             'timecopied' => 0
 247         );
 248         $definitionid = $DB->insert_record('grading_definitions', $rubricdefinition);
 249
 250         // Create a criterion with a level.
 251         $rubriccriteria = array (
 252             'definitionid' => $definitionid,
 253             'sortorder' => 1,
 254             'description' => 'Demonstrate an understanding of disease control',
 255             'descriptionformat' => 0
 256         );
 257         $criterionid = $DB->insert_record('gradingform_rubric_criteria', $rubriccriteria);
 258         $rubriclevel = array (
 259             'criterionid' => $criterionid,
 260             'score' => 50,
 261             'definition' => 'pass',
 262             'definitionformat' => 0
 263         );
 264         $levelid = $DB->insert_record('gradingform_rubric_levels', $rubriclevel);
 265
 266         // Create a grading instance.
 267         $instance = array (
 268             'definitionid' => $definitionid,
 269             'raterid' => $USER->id,
 270             'itemid' => $gid,
 271             'status' => 1,
 272             'feedbackformat' => 0,
 273             'timemodified' => 1
 274         );
 275         $instanceid = $DB->insert_record('grading_instances', $instance);
 276
 277         // Create a filling.
 278         $filling = array (
 279             'instanceid' => $instanceid,
 280             'criterionid' => $criterionid,
 281             'levelid' => $levelid,
 282             'remark' => 'excellent work',
 283             'remarkformat' => 0
 284         );
 285         $DB->insert_record('gradingform_rubric_fillings', $filling);
 286
 287         // Call the external function.
 288         $result = core_grading_external::get_gradingform_instances($definitionid, 0);
 289         $result = external_api::clean_returnvalue(core_grading_external::get_gradingform_instances_returns(), $result);
 290
 291         $this->assertEquals(1, count($result['instances']));
 292         $this->assertEquals($USER->id, $result['instances'][0]['raterid']);
 293         $this->assertEquals($gid, $result['instances'][0]['itemid']);
 294         $this->assertEquals(1, $result['instances'][0]['status']);
 295         $this->assertEquals(1, $result['instances'][0]['timemodified']);
 296         $this->assertEquals(1, count($result['instances'][0]['rubric']));
 297         $this->assertEquals(1, count($result['instances'][0]['rubric']['criteria']));
 298         $criteria = $result['instances'][0]['rubric']['criteria'];
 299         $this->assertEquals($criterionid, $criteria[0]['criterionid']);
 300         $this->assertEquals($levelid, $criteria[0]['levelid']);
 301         $this->assertEquals('excellent work', $criteria[0]['remark']);
 302     }
 303
 304     /**
 305      *
 306      * Test save_definitions for rubric grading method
 307      */
 308     public function test_save_definitions_rubric() {
 309         global $DB, $CFG, $USER;
 310
 311         $this->resetAfterTest(true);
 312         // Create a course and assignment.
 313         $course = self::getDataGenerator()->create_course();
 314         $generator = $this->getDataGenerator()->get_plugin_generator('mod_assign');
 315         $params['course'] = $course->id;
 316         $instance = $generator->create_instance($params);
 317         $cm = get_coursemodule_from_instance('assign', $instance->id);
 318         $context = context_module::instance($cm->id);
 319         $coursecontext = context_course::instance($course->id);
 320
 321         // Create the teacher.
 322         $teacher = self::getDataGenerator()->create_user();
 323         $USER->id = $teacher->id;
 324         $teacherrole = $DB->get_record('role', array('shortname' => 'editingteacher'));
 325         $this->assignUserCapability('moodle/grade:managegradingforms', $context->id, $teacherrole->id);
 326         $this->getDataGenerator()->enrol_user($teacher->id,
 327                                               $course->id,
 328                                               $teacherrole->id);
 329
 330         // The grading area to insert.
 331         $gradingarea = array(
 332             'cmid' => $cm->id,
 333             'contextid' => $context->id,
 334             'component' => 'mod_assign',
 335             'areaname'  => 'submissions',
 336             'activemethod' => 'rubric'
 337         );
 338
 339         // The rubric definition to insert.
 340         $rubricdefinition = array(
 341             'method' => 'rubric',
 342             'name' => 'test',
 343             'description' => '',
 344             'status' => 20,
 345             'copiedfromid' => 1,
 346             'timecreated' => 1,
 347             'usercreated' => $teacher->id,
 348             'timemodified' => 1,
 349             'usermodified' => $teacher->id,
 350             'timecopied' => 0
 351         );
 352
 353         // The criterion to insert.
 354         $rubriccriteria1 = array (
 355              'sortorder' => 1,
 356              'description' => 'Demonstrate an understanding of disease control',
 357              'descriptionformat' => 0
 358         );
 359
 360         // 3 levels for the criterion.
 361         $rubriclevel1 = array (
 362             'score' => 50,
 363             'definition' => 'pass',
 364             'definitionformat' => 0
 365         );
 366         $rubriclevel2 = array (
 367             'score' => 100,
 368             'definition' => 'excellent',
 369             'definitionformat' => 0
 370         );
 371         $rubriclevel3 = array (
 372             'score' => 0,
 373             'definition' => 'fail',
 374             'definitionformat' => 0
 375         );
 376
 377         $rubriccriteria1['levels'] = array($rubriclevel1, $rubriclevel2, $rubriclevel3);
 378         $rubricdefinition['rubric'] = array('rubric_criteria' => array($rubriccriteria1));
 379         $gradingarea['definitions'] = array($rubricdefinition);
 380
 381         $results = core_grading_external::save_definitions(array($gradingarea));
 382
 383         $area = $DB->get_record('grading_areas',
 384                                 array('contextid' => $context->id, 'component' => 'mod_assign', 'areaname' => 'submissions'),
 385                                 '*', MUST_EXIST);
 386         $this->assertEquals($area->activemethod, 'rubric');
 387
 388         $definition = $DB->get_record('grading_definitions', array('areaid' => $area->id, 'method' => 'rubric'), '*', MUST_EXIST);
 389         $this->assertEquals($rubricdefinition['name'], $definition->name);
 390
 391         $criterion1 = $DB->get_record('gradingform_rubric_criteria', array('definitionid' => $definition->id), '*', MUST_EXIST);
 392         $levels = $DB->get_records('gradingform_rubric_levels', array('criterionid' => $criterion1->id));
 393         $validlevelcount = 0;
 394         $expectedvalue = true;
 395         foreach ($levels as $level) {
 396             if ($level->score == 0) {
 397                 $this->assertEquals('fail', $level->definition);
 398                 $validlevelcount++;
 399             } else if ($level->score == 50) {
 400                 $this->assertEquals('pass', $level->definition);
 401                 $validlevelcount++;
 402             } else if ($level->score == 100) {
 403                 $this->assertEquals('excellent', $level->definition);
 404                 $excellentlevelid = $level->id;
 405                 $validlevelcount++;
 406             } else {
 407                 $expectedvalue = false;
 408             }
 409         }
 410         $this->assertEquals(3, $validlevelcount);
 411         $this->assertTrue($expectedvalue, 'A level with an unexpected score was found');
 412
 413         // Test add a new level and modify an existing.
 414         // Test add a new criteria and modify an existing.
 415         // Test modify a definition.
 416
 417         // The rubric definition to update.
 418         $rubricdefinition = array(
 419             'id' => $definition->id,
 420             'method' => 'rubric',
 421             'name' => 'test changed',
 422             'description' => '',
 423             'status' => 20,
 424             'copiedfromid' => 1,
 425             'timecreated' => 1,
 426             'usercreated' => $teacher->id,
 427             'timemodified' => 1,
 428             'usermodified' => $teacher->id,
 429             'timecopied' => 0
 430         );
 431
 432         // A criterion to update.
 433         $rubriccriteria1 = array (
 434              'id' => $criterion1->id,
 435              'sortorder' => 1,
 436              'description' => 'Demonstrate an understanding of rabies control',
 437              'descriptionformat' => 0
 438         );
 439
 440         // A new criterion to add.
 441         $rubriccriteria2 = array (
 442              'sortorder' => 2,
 443              'description' => 'Demonstrate an understanding of anthrax control',
 444              'descriptionformat' => 0
 445         );
 446
 447         // A level to update.
 448         $rubriclevel2 = array (
 449             'id' => $excellentlevelid,
 450             'score' => 75,
 451             'definition' => 'excellent',
 452             'definitionformat' => 0
 453         );
 454
 455         // A level to insert.
 456         $rubriclevel4 = array (
 457             'score' => 100,
 458             'definition' => 'superb',
 459             'definitionformat' => 0
 460         );
 461
 462         $rubriccriteria1['levels'] = array($rubriclevel1, $rubriclevel2, $rubriclevel3, $rubriclevel4);
 463         $rubricdefinition['rubric'] = array('rubric_criteria' => array($rubriccriteria1, $rubriccriteria2));
 464         $gradingarea['definitions'] = array($rubricdefinition);
 465
 466         $results = core_grading_external::save_definitions(array($gradingarea));
 467
 468         // Test definition name change.
 469         $definition = $DB->get_record('grading_definitions', array('id' => $definition->id), '*', MUST_EXIST);
 470         $this->assertEquals('test changed', $definition->name);
 471
 472         // Test criteria description change.
 473         $modifiedcriteria = $DB->get_record('gradingform_rubric_criteria', array('id' => $criterion1->id), '*', MUST_EXIST);
 474         $this->assertEquals('Demonstrate an understanding of rabies control', $modifiedcriteria->description);
 475
 476         // Test new criteria added.
 477         $newcriteria = $DB->get_record('gradingform_rubric_criteria',
 478                                        array('definitionid' => $definition->id, 'sortorder' => 2), '*', MUST_EXIST);
 479         $this->assertEquals('Demonstrate an understanding of anthrax control', $newcriteria->description);
 480
 481         // Test excellent level score change from 100 to 75.
 482         $modifiedlevel = $DB->get_record('gradingform_rubric_levels', array('id' => $excellentlevelid), '*', MUST_EXIST);
 483         $this->assertEquals(75, $modifiedlevel->score);
 484
 485         // Test new superb level added.
 486         $newlevel = $DB->get_record('gradingform_rubric_levels',
 487                                        array('criterionid' => $criterion1->id, 'score' => 100), '*', MUST_EXIST);
 488         $this->assertEquals('superb', $newlevel->definition);
 489
 490         // Test remove a level
 491         // Test remove a criterion
 492         // The rubric definition with the removed criterion and levels.
 493         $rubricdefinition = array(
 494             'id' => $definition->id,
 495             'method' => 'rubric',
 496             'name' => 'test changed',
 497             'description' => '',
 498             'status' => 20,
 499             'copiedfromid' => 1,
 500             'timecreated' => 1,
 501             'usercreated' => $teacher->id,
 502             'timemodified' => 1,
 503             'usermodified' => $teacher->id,
 504             'timecopied' => 0
 505         );
 506
 507         $rubriccriteria1 = array (
 508              'id' => $criterion1->id,
 509              'sortorder' => 1,
 510              'description' => 'Demonstrate an understanding of rabies control',
 511              'descriptionformat' => 0
 512         );
 513
 514         $rubriclevel1 = array (
 515             'score' => 0,
 516             'definition' => 'fail',
 517             'definitionformat' => 0
 518         );
 519         $rubriclevel2 = array (
 520             'score' => 100,
 521             'definition' => 'pass',
 522             'definitionformat' => 0
 523         );
 524
 525         $rubriccriteria1['levels'] = array($rubriclevel1, $rubriclevel2);
 526         $rubricdefinition['rubric'] = array('rubric_criteria' => array($rubriccriteria1));
 527         $gradingarea['definitions'] = array($rubricdefinition);
 528
 529         $results = core_grading_external::save_definitions(array($gradingarea));
 530
 531         // Only 1 criterion should now exist.
 532         $this->assertEquals(1, $DB->count_records('gradingform_rubric_criteria', array('definitionid' => $definition->id)));
 533         $criterion1 = $DB->get_record('gradingform_rubric_criteria', array('definitionid' => $definition->id), '*', MUST_EXIST);
 534         $this->assertEquals('Demonstrate an understanding of rabies control', $criterion1->description);
 535         // This criterion should only have 2 levels.
 536         $this->assertEquals(2, $DB->count_records('gradingform_rubric_levels', array('criterionid' => $criterion1->id)));
 537
 538         $gradingarea['activemethod'] = 'invalid';
 539         $this->setExpectedException('moodle_exception');
 540         $results = core_grading_external::save_definitions(array($gradingarea));
 541     }
 542
 543     /**
 544      *
 545      * Tests save_definitions for the marking guide grading method
 546      */
 547     public function test_save_definitions_marking_guide() {
 548         global $DB, $CFG, $USER;
 549
 550         $this->resetAfterTest(true);
 551         // Create a course and assignment.
 552         $course = self::getDataGenerator()->create_course();
 553         $generator = $this->getDataGenerator()->get_plugin_generator('mod_assign');
 554         $params['course'] = $course->id;
 555         $instance = $generator->create_instance($params);
 556         $cm = get_coursemodule_from_instance('assign', $instance->id);
 557         $context = context_module::instance($cm->id);
 558         $coursecontext = context_course::instance($course->id);
 559
 560         // Create the teacher.
 561         $teacher = self::getDataGenerator()->create_user();
 562         $USER->id = $teacher->id;
 563         $teacherrole = $DB->get_record('role', array('shortname' => 'editingteacher'));
 564         $this->assignUserCapability('moodle/grade:managegradingforms', $context->id, $teacherrole->id);
 565         $this->getDataGenerator()->enrol_user($teacher->id,
 566                                               $course->id,
 567                                               $teacherrole->id);
 568
 569         // Test insert a grading area with guide definition, criteria and comments.
 570         $gradingarea = array(
 571             'cmid' => $cm->id,
 572             'contextid' => $context->id,
 573             'component' => 'mod_assign',
 574             'areaname'  => 'submissions',
 575             'activemethod' => 'guide'
 576         );
 577
 578         $guidedefinition = array(
 579             'method' => 'guide',
 580             'name' => 'test',
 581             'description' => '',
 582             'status' => 20,
 583             'copiedfromid' => 1,
 584             'timecreated' => 1,
 585             'usercreated' => $teacher->id,
 586             'timemodified' => 1,
 587             'usermodified' => $teacher->id,
 588             'timecopied' => 0
 589         );
 590
 591         $guidecomment = array(
 592              'sortorder' => 1,
 593              'description' => 'Students need to show that they understand the control of zoonoses',
 594              'descriptionformat' => 0
 595         );
 596         $guidecriteria1 = array (
 597              'sortorder' => 1,
 598              'shortname' => 'Rabies Control',
 599              'description' => 'Understand rabies control techniques',
 600              'descriptionformat' => 0,
 601              'descriptionmarkers' => 'Student must demonstrate that they understand rabies control',
 602              'descriptionmarkersformat' => 0,
 603              'maxscore' => 50
 604         );
 605         $guidecriteria2 = array (
 606              'sortorder' => 2,
 607              'shortname' => 'Anthrax Control',
 608              'description' => 'Understand anthrax control',
 609              'descriptionformat' => 0,
 610              'descriptionmarkers' => 'Student must demonstrate that they understand anthrax control',
 611              'descriptionmarkersformat' => 0,
 612              'maxscore' => 50
 613         );
 614
 615         $guidedefinition['guide'] = array('guide_criteria' => array($guidecriteria1, $guidecriteria2),
 616                                           'guide_comments' => array($guidecomment));
 617         $gradingarea['definitions'] = array($guidedefinition);
 618
 619         $results = core_grading_external::save_definitions(array($gradingarea));
 620         $area = $DB->get_record('grading_areas',
 621                                 array('contextid' => $context->id, 'component' => 'mod_assign', 'areaname' => 'submissions'),
 622                                 '*', MUST_EXIST);
 623         $this->assertEquals($area->activemethod, 'guide');
 624
 625         $definition = $DB->get_record('grading_definitions', array('areaid' => $area->id, 'method' => 'guide'), '*', MUST_EXIST);
 626         $this->assertEquals($guidedefinition['name'], $definition->name);
 627         $this->assertEquals(2, $DB->count_records('gradingform_guide_criteria', array('definitionid' => $definition->id)));
 628         $this->assertEquals(1, $DB->count_records('gradingform_guide_comments', array('definitionid' => $definition->id)));
 629
 630         // Test removal of a criteria.
 631         $guidedefinition['guide'] = array('guide_criteria' => array($guidecriteria1),
 632                                           'guide_comments' => array($guidecomment));
 633         $gradingarea['definitions'] = array($guidedefinition);
 634         $results = core_grading_external::save_definitions(array($gradingarea));
 635         $this->assertEquals(1, $DB->count_records('gradingform_guide_criteria', array('definitionid' => $definition->id)));
 636
 637         // Test an invalid method in the definition.
 638         $guidedefinition['method'] = 'invalid';
 639         $gradingarea['definitions'] = array($guidedefinition);
 640         $this->setExpectedException('invalid_parameter_exception');
 641         $results = core_grading_external::save_definitions(array($gradingarea));
 642     }
 643 }