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