lib/grade/simpletest/testgradeitem.php

   1 <?php // $Id$
   2
   3 ///////////////////////////////////////////////////////////////////////////
   4 //                                                                       //
   5 // NOTICE OF COPYRIGHT                                                   //
   6 //                                                                       //
   7 // Moodle - Modular Object-Oriented Dynamic Learning Environment         //
   8 //          http://moodle.org                                            //
   9 //                                                                       //
  10 // Copyright (C) 1999-2004  Martin Dougiamas  http://dougiamas.com       //
  11 //                                                                       //
  12 // This program is free software; you can redistribute it and/or modify  //
  13 // it under the terms of the GNU General Public License as published by  //
  14 // the Free Software Foundation; either version 2 of the License, or     //
  15 // (at your option) any later version.                                   //
  16 //                                                                       //
  17 // This program is distributed in the hope that it will be useful,       //
  18 // but WITHOUT ANY WARRANTY; without even the implied warranty of        //
  19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         //
  20 // GNU General Public License for more details:                          //
  21 //                                                                       //
  22 //          http://www.gnu.org/copyleft/gpl.html                         //
  23 //                                                                       //
  24 ///////////////////////////////////////////////////////////////////////////
  25
  26 /**
  27  * Unit tests for grade_item object.
  28  *
  29  * @author nicolas@moodle.com
  30  * @license http://www.gnu.org/copyleft/gpl.html GNU Public License
  31  * @package moodlecore
  32  */
  33
  34 if (!defined('MOODLE_INTERNAL')) {
  35     die('Direct access to this script is forbidden.');    ///  It must be included from a Moodle page
  36 }
  37
  38 require_once($CFG->libdir.'/simpletest/fixtures/gradetest.php');
  39
  40 @set_time_limit(0);
  41
  42 class grade_item_test extends grade_test {
  43
  44     function test_grade_item_construct() {
  45         $params = new stdClass();
  46
  47         $params->courseid = $this->courseid;
  48         $params->categoryid = $this->grade_categories[1]->id;
  49         $params->itemname = 'unittestgradeitem4';
  50         $params->itemtype = 'mod';
  51         $params->itemmodule = 'database';
  52         $params->iteminfo = 'Grade item used for unit testing';
  53
  54         $grade_item = new grade_item($params, false);
  55
  56         $this->assertEqual($params->courseid, $grade_item->courseid);
  57         $this->assertEqual($params->categoryid, $grade_item->categoryid);
  58         $this->assertEqual($params->itemmodule, $grade_item->itemmodule);
  59     }
  60
  61     function test_grade_item_insert() {
  62         $grade_item = new grade_item();
  63         $this->assertTrue(method_exists($grade_item, 'insert'));
  64
  65         $grade_item->courseid = $this->courseid;
  66         $grade_item->categoryid = $this->grade_categories[1]->id;
  67         $grade_item->itemname = 'unittestgradeitem4';
  68         $grade_item->itemtype = 'mod';
  69         $grade_item->itemmodule = 'quiz';
  70         $grade_item->iteminfo = 'Grade item used for unit testing';
  71
  72         $grade_item->insert();
  73
  74         $last_grade_item = end($this->grade_items);
  75
  76         $this->assertEqual($grade_item->id, $last_grade_item->id + 1);
  77         $this->assertEqual(11, $grade_item->sortorder);
  78     }
  79
  80     function test_grade_item_delete() {
  81         $grade_item = new grade_item($this->grade_items[0]);
  82         $this->assertTrue(method_exists($grade_item, 'delete'));
  83
  84         $this->assertTrue($grade_item->delete());
  85
  86         $this->assertFalse(get_record('grade_items', 'id', $grade_item->id));
  87     }
  88
  89     function test_grade_item_update() {
  90         $grade_item = new grade_item($this->grade_items[0]);
  91         $this->assertTrue(method_exists($grade_item, 'update'));
  92
  93         $grade_item->iteminfo = 'Updated info for this unittest grade_item';
  94
  95         $this->assertTrue($grade_item->update());
  96
  97         $grade_item->grademin = 14;
  98         $this->assertTrue($grade_item->qualifies_for_regrading());
  99         $this->assertTrue($grade_item->update());
 100
 101         $iteminfo = get_field('grade_items', 'iteminfo', 'id', $this->grade_items[0]->id);
 102         $this->assertEqual($grade_item->iteminfo, $iteminfo);
 103     }
 104
 105     function test_grade_item_load_scale() {
 106         $grade_item = new grade_item($this->grade_items[2]);
 107         $this->assertTrue(method_exists($grade_item, 'load_scale'));
 108         $scale = $grade_item->load_scale();
 109         $this->assertFalse(empty($grade_item->scale));
 110         $this->assertEqual($scale->id, $this->grade_items[2]->scaleid);
 111     }
 112
 113     function test_grade_item_load_outcome() {
 114         $grade_item = new grade_item($this->grade_items[0]);
 115         $this->assertTrue(method_exists($grade_item, 'load_outcome'));
 116         //TODO: add tests
 117     }
 118
 119     function test_grade_item_qualifies_for_regrading() {
 120         $grade_item = new grade_item($this->grade_items[0]);
 121         $this->assertTrue(method_exists($grade_item, 'qualifies_for_regrading'));
 122
 123         $this->assertFalse($grade_item->qualifies_for_regrading());
 124
 125         $grade_item->iteminfo = 'Updated info for this unittest grade_item';
 126
 127         $this->assertFalse($grade_item->qualifies_for_regrading());
 128
 129         $grade_item->grademin = 14;
 130
 131         $this->assertTrue($grade_item->qualifies_for_regrading());
 132     }
 133
 134     function test_grade_item_force_regrading() {
 135         $grade_item = new grade_item($this->grade_items[0]);
 136         $this->assertTrue(method_exists($grade_item, 'force_regrading'));
 137
 138         $this->assertEqual(0, $grade_item->needsupdate);
 139
 140         $grade_item->force_regrading();
 141         $this->assertEqual(1, $grade_item->needsupdate);
 142         $grade_item->update_from_db();
 143         $this->assertEqual(1, $grade_item->needsupdate);
 144     }
 145
 146     function test_grade_item_fetch() {
 147         $grade_item = new grade_item();
 148         $this->assertTrue(method_exists($grade_item, 'fetch'));
 149
 150         $grade_item = grade_item::fetch(array('id'=>$this->grade_items[0]->id));
 151         $this->assertEqual($this->grade_items[0]->id, $grade_item->id);
 152         $this->assertEqual($this->grade_items[0]->iteminfo, $grade_item->iteminfo);
 153
 154         $grade_item = grade_item::fetch(array('itemtype'=>$this->grade_items[1]->itemtype, 'itemmodule'=>$this->grade_items[1]->itemmodule));
 155         $this->assertEqual($this->grade_items[1]->id, $grade_item->id);
 156         $this->assertEqual($this->grade_items[1]->iteminfo, $grade_item->iteminfo);
 157     }
 158
 159     function test_grade_item_fetch_all() {
 160         $grade_item = new grade_item();
 161         $this->assertTrue(method_exists($grade_item, 'fetch_all'));
 162
 163         $grade_items = grade_item::fetch_all(array('courseid'=>$this->courseid));
 164         $this->assertEqual(count($this->grade_items), count($grade_items)-1);
 165     }
 166
 167     /**
 168      * Retrieve all final scores for a given grade_item.
 169      */
 170     function test_grade_item_get_all_finals() {
 171         $grade_item = new grade_item($this->grade_items[0]);
 172         $this->assertTrue(method_exists($grade_item, 'get_final'));
 173
 174         $final_grades = $grade_item->get_final();
 175         $this->assertEqual(3, count($final_grades));
 176     }
 177
 178
 179     /**
 180      * Retrieve all final scores for a specific userid.
 181      */
 182     function test_grade_item_get_final() {
 183         $grade_item = new grade_item($this->grade_items[0]);
 184         $this->assertTrue(method_exists($grade_item, 'get_final'));
 185         $final_grade = $grade_item->get_final($this->userid);
 186         $this->assertEqual($this->grade_grades[0]->finalgrade, $final_grade->finalgrade);
 187     }
 188
 189     function test_grade_item_get_sortorder() {
 190         $grade_item = new grade_item($this->grade_items[0]);
 191         $this->assertTrue(method_exists($grade_item, 'get_sortorder'));
 192         $sortorder = $grade_item->get_sortorder();
 193         $this->assertEqual($this->grade_items[0]->sortorder, $sortorder);
 194     }
 195
 196     function test_grade_item_set_sortorder() {
 197         $grade_item = new grade_item($this->grade_items[0]);
 198         $this->assertTrue(method_exists($grade_item, 'set_sortorder'));
 199         $grade_item->set_sortorder(999);
 200         $this->assertEqual($grade_item->sortorder, 999);
 201     }
 202
 203     function test_grade_item_move_after_sortorder() {
 204         $grade_item = new grade_item($this->grade_items[0]);
 205         $this->assertTrue(method_exists($grade_item, 'move_after_sortorder'));
 206         $grade_item->move_after_sortorder(5);
 207         $this->assertEqual($grade_item->sortorder, 6);
 208
 209         $grade_item = grade_item::fetch(array('id'=>$this->grade_items[0]->id));
 210         $this->assertEqual($grade_item->sortorder, 6);
 211
 212         $after = grade_item::fetch(array('id'=>$this->grade_items[6]->id));
 213         $this->assertEqual($after->sortorder, 8);
 214     }
 215
 216     function test_grade_item_get_name() {
 217         $grade_item = new grade_item($this->grade_items[0]);
 218         $this->assertTrue(method_exists($grade_item, 'get_name'));
 219
 220         $name = $grade_item->get_name();
 221         $this->assertEqual($this->grade_items[0]->itemname, $name);
 222     }
 223
 224     function test_grade_item_set_parent() {
 225         $grade_item = new grade_item($this->grade_items[0]);
 226         $this->assertTrue(method_exists($grade_item, 'set_parent'));
 227
 228         $old = $grade_item->get_parent_category();
 229         $new = new grade_category($this->grade_categories[3]);
 230         $new_item = $new->get_grade_item();
 231
 232         $this->assertTrue($grade_item->set_parent($new->id));
 233
 234         $new_item->update_from_db();
 235         $grade_item->update_from_db();
 236
 237         $this->assertEqual($grade_item->categoryid, $new->id);
 238     }
 239
 240     function test_grade_item_get_parent_category() {
 241         $grade_item = new grade_item($this->grade_items[0]);
 242         $this->assertTrue(method_exists($grade_item, 'get_parent_category'));
 243
 244         $category = $grade_item->get_parent_category();
 245         $this->assertEqual($this->grade_categories[1]->fullname, $category->fullname);
 246     }
 247
 248     function test_grade_item_load_parent_category() {
 249         $grade_item = new grade_item($this->grade_items[0]);
 250         $this->assertTrue(method_exists($grade_item, 'load_parent_category'));
 251
 252         $category = $grade_item->load_parent_category();
 253         $this->assertEqual($this->grade_categories[1]->fullname, $category->fullname);
 254         $this->assertEqual($this->grade_categories[1]->fullname, $grade_item->parent_category->fullname);
 255     }
 256
 257     function test_grade_item_get_item_category() {
 258         $grade_item = new grade_item($this->grade_items[3]);
 259         $this->assertTrue(method_exists($grade_item, 'get_item_category'));
 260
 261         $category = $grade_item->get_item_category();
 262         $this->assertEqual($this->grade_categories[0]->fullname, $category->fullname);
 263     }
 264
 265     function test_grade_item_load_item_category() {
 266         $grade_item = new grade_item($this->grade_items[3]);
 267         $this->assertTrue(method_exists($grade_item, 'load_item_category'));
 268
 269         $category = $grade_item->load_item_category();
 270         $this->assertEqual($this->grade_categories[0]->fullname, $category->fullname);
 271         $this->assertEqual($this->grade_categories[0]->fullname, $grade_item->item_category->fullname);
 272     }
 273
 274     /**
 275      * Test update of all final grades
 276      */
 277     function test_grade_item_regrade_final_grades() {
 278         $grade_item = new grade_item($this->grade_items[0]);
 279         $this->assertTrue(method_exists($grade_item, 'regrade_final_grades'));
 280         $this->assertEqual(true, $grade_item->regrade_final_grades());
 281         //TODO: add more tests
 282     }
 283
 284     /**
 285      * Test the adjust_raw_grade method
 286      */
 287     function test_grade_item_adjust_raw_grade() {
 288         $grade_item = new grade_item($this->grade_items[0]);
 289         $this->assertTrue(method_exists($grade_item, 'adjust_raw_grade'));
 290         $grade_raw = new stdClass();
 291
 292         $grade_raw->rawgrade = 40;
 293         $grade_raw->grademax = 100;
 294         $grade_raw->grademin = 0;
 295
 296         $grade_item->multfactor = 1;
 297         $grade_item->plusfactor = 0;
 298         $grade_item->grademax = 50;
 299         $grade_item->grademin = 0;
 300
 301         $original_grade_raw  = clone($grade_raw);
 302         $original_grade_item = clone($grade_item);
 303
 304         $this->assertEqual(20, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
 305
 306         // Try a larger maximum grade
 307         $grade_item->grademax = 150;
 308         $grade_item->grademin = 0;
 309         $this->assertEqual(60, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
 310
 311         // Try larger minimum grade
 312         $grade_item->grademin = 50;
 313
 314         $this->assertEqual(90, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
 315
 316         // Rescaling from a small scale (0-50) to a larger scale (0-100)
 317         $grade_raw->grademax = 50;
 318         $grade_raw->grademin = 0;
 319         $grade_item->grademax = 100;
 320         $grade_item->grademin = 0;
 321
 322         $this->assertEqual(80, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
 323
 324         // Rescaling from a small scale (0-50) to a larger scale with offset (40-100)
 325         $grade_item->grademax = 100;
 326         $grade_item->grademin = 40;
 327
 328         $this->assertEqual(88, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
 329
 330         // Try multfactor and plusfactor
 331         $grade_raw = clone($original_grade_raw);
 332         $grade_item = clone($original_grade_item);
 333         $grade_item->multfactor = 1.23;
 334         $grade_item->plusfactor = 3;
 335
 336         $this->assertEqual(27.6, $grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax));
 337
 338         // Try multfactor below 0 and a negative plusfactor
 339         $grade_raw = clone($original_grade_raw);
 340         $grade_item = clone($original_grade_item);
 341         $grade_item->multfactor = 0.23;
 342         $grade_item->plusfactor = -3;
 343
 344         $this->assertEqual(round(1.6), round($grade_item->adjust_raw_grade($grade_raw->rawgrade, $grade_raw->grademin, $grade_raw->grademax)));
 345     }
 346
 347     /**
 348      * Test locking of grade items
 349      */
 350     function test_grade_item_set_locked() {
 351         $grade_item = new grade_item($this->grade_items[0]);
 352         $this->assertTrue(method_exists($grade_item, 'set_locked'));
 353
 354         $grade = new grade_grade($grade_item->get_final(1));
 355         $this->assertTrue(empty($grade_item->locked));
 356         $this->assertTrue(empty($grade->locked));
 357
 358         $this->assertTrue($grade_item->set_locked(true));
 359         $grade = new grade_grade($grade_item->get_final(1));
 360
 361         $this->assertFalse(empty($grade_item->locked));
 362         $this->assertFalse(empty($grade->locked)); // individual grades should be locked too
 363
 364         $this->assertTrue($grade_item->set_locked(false));
 365         $grade = new grade_grade($grade_item->get_final(1));
 366
 367         $this->assertTrue(empty($grade_item->locked));
 368         $this->assertTrue(empty($grade->locked)); // individual grades should be unlocked too
 369     }
 370
 371     function test_grade_item_is_locked() {
 372         $grade_item = new grade_item($this->grade_items[0]);
 373         $this->assertTrue(method_exists($grade_item, 'is_locked'));
 374
 375         $this->assertFalse($grade_item->is_locked());
 376         $this->assertFalse($grade_item->is_locked(1));
 377         $this->assertTrue($grade_item->set_locked(true));
 378         $this->assertTrue($grade_item->is_locked());
 379         $this->assertTrue($grade_item->is_locked(1));
 380     }
 381
 382     /**
 383      * Test hiding of grade items
 384      */
 385     function test_grade_item_set_hidden() {
 386         $grade_item = new grade_item($this->grade_items[0]);
 387         $this->assertTrue(method_exists($grade_item, 'set_hidden'));
 388
 389         $grade = new grade_grade($grade_item->get_final(1));
 390         $this->assertEqual(0, $grade_item->hidden);
 391         $this->assertEqual(0, $grade->hidden);
 392
 393         $grade_item->set_hidden(666);
 394         $grade = new grade_grade($grade_item->get_final(1));
 395
 396         $this->assertEqual(666, $grade_item->hidden);
 397         $this->assertEqual(666, $grade->hidden);
 398     }
 399
 400     function test_grade_item_is_hidden() {
 401         $grade_item = new grade_item($this->grade_items[0]);
 402         $this->assertTrue(method_exists($grade_item, 'is_hidden'));
 403
 404         $this->assertFalse($grade_item->is_hidden());
 405         $this->assertFalse($grade_item->is_hidden(1));
 406
 407         $grade_item->set_hidden(1);
 408         $this->assertTrue($grade_item->is_hidden());
 409         $this->assertTrue($grade_item->is_hidden(1));
 410
 411         $grade_item->set_hidden(666);
 412         $this->assertFalse($grade_item->is_hidden());
 413         $this->assertFalse($grade_item->is_hidden(1));
 414
 415         $grade_item->set_hidden(time()+666);
 416         $this->assertTrue($grade_item->is_hidden());
 417         $this->assertTrue($grade_item->is_hidden(1));
 418     }
 419
 420     function test_grade_item_is_category_item() {
 421         $grade_item = new grade_item($this->grade_items[3]);
 422         $this->assertTrue(method_exists($grade_item, 'is_category_item'));
 423         $this->assertTrue($grade_item->is_category_item());
 424     }
 425
 426     function test_grade_item_is_course_item() {
 427         $grade_item = grade_item::fetch_course_item($this->courseid);
 428         $this->assertTrue(method_exists($grade_item, 'is_course_item'));
 429         $this->assertTrue($grade_item->is_course_item());
 430     }
 431
 432     function test_grade_item_fetch_course_item() {
 433         $grade_item = grade_item::fetch_course_item($this->courseid);
 434         $this->assertTrue(method_exists($grade_item, 'fetch_course_item'));
 435         $this->assertTrue($grade_item->itemtype, 'course');
 436     }
 437
 438     function test_grade_item_depends_on() {
 439         $grade_item = new grade_item($this->grade_items[1]);
 440
 441         // calculated grade dependency
 442         $deps = $grade_item->depends_on();
 443         sort($deps, SORT_NUMERIC); // for comparison
 444         $this->assertEqual(array($this->grade_items[0]->id), $deps);
 445
 446         // simulate depends on returns none when locked
 447         $grade_item->locked = time();
 448         $grade_item->update();
 449         $deps = $grade_item->depends_on();
 450         sort($deps, SORT_NUMERIC); // for comparison
 451         $this->assertEqual(array(), $deps);
 452
 453         // category dependency
 454         $grade_item = new grade_item($this->grade_items[3]);
 455         $deps = $grade_item->depends_on();
 456         sort($deps, SORT_NUMERIC); // for comparison
 457         $res = array($this->grade_items[4]->id, $this->grade_items[5]->id);
 458         $this->assertEqual($res, $deps);
 459     }
 460
 461     function test_grade_item_is_calculated() {
 462         $grade_item = new grade_item($this->grade_items[1]);
 463         $this->assertTrue(method_exists($grade_item, 'is_calculated'));
 464         $grade_itemsource = new grade_item($this->grade_items[0]);
 465         $normalizedformula = str_replace('[['.$grade_itemsource->idnumber.']]', '##gi'.$grade_itemsource->id.'##', $this->grade_items[1]->calculation);
 466
 467         $this->assertTrue($grade_item->is_calculated());
 468         $this->assertEqual($normalizedformula, $grade_item->calculation);
 469     }
 470
 471     function test_grade_item_set_calculation() {
 472         $grade_item = new grade_item($this->grade_items[1]);
 473         $this->assertTrue(method_exists($grade_item, 'set_calculation'));
 474         $grade_itemsource = new grade_item($this->grade_items[0]);
 475
 476         $grade_item->set_calculation('=[['.$grade_itemsource->idnumber.']]');
 477
 478         $this->assertTrue(!empty($grade_item->needsupdate));
 479         $this->assertEqual('=##gi'.$grade_itemsource->id.'##', $grade_item->calculation);
 480     }
 481
 482     function test_grade_item_get_calculation() {
 483         $grade_item = new grade_item($this->grade_items[1]);
 484         $this->assertTrue(method_exists($grade_item, 'get_calculation'));
 485         $grade_itemsource = new grade_item($this->grade_items[0]);
 486
 487         $denormalizedformula = str_replace('##gi'.$grade_itemsource->id.'##', '[['.$grade_itemsource->idnumber.']]', $this->grade_items[1]->calculation);
 488
 489         $formula = $grade_item->get_calculation();
 490         $this->assertTrue(!empty($grade_item->needsupdate));
 491         $this->assertEqual($denormalizedformula, $formula);
 492     }
 493
 494     function test_grade_item_compute() {
 495         $grade_item = new grade_item($this->grade_items[1]);
 496         $this->assertTrue(method_exists($grade_item, 'compute'));
 497
 498         $grade_grade = grade_grade::fetch(array('id'=>$this->grade_grades[3]->id));
 499         $grade_grade->delete();
 500         $grade_grade = grade_grade::fetch(array('id'=>$this->grade_grades[4]->id));
 501         $grade_grade->delete();
 502         $grade_grade = grade_grade::fetch(array('id'=>$this->grade_grades[5]->id));
 503         $grade_grade->delete();
 504
 505         $grade_item->compute();
 506
 507         $grade_grade = grade_grade::fetch(array('userid'=>$this->grade_grades[3]->userid, 'itemid'=>$this->grade_grades[3]->itemid));
 508         $this->assertEqual($this->grade_grades[3]->finalgrade, $grade_grade->finalgrade);
 509         $grade_grade = grade_grade::fetch(array('userid'=>$this->grade_grades[4]->userid, 'itemid'=>$this->grade_grades[4]->itemid));
 510         $this->assertEqual($this->grade_grades[4]->finalgrade, $grade_grade->finalgrade);
 511         $grade_grade = grade_grade::fetch(array('userid'=>$this->grade_grades[5]->userid, 'itemid'=>$this->grade_grades[5]->itemid));
 512         $this->assertEqual($this->grade_grades[5]->finalgrade, $grade_grade->finalgrade);
 513     }
 514
 515 }
 516 ?>