[Summary view] [Print] [Text view]

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